API tools faq
paste
View difference between Paste ID: JCJqz5Nj and hVNbE37x
SHOW: | | - or go back to the newest paste.
1
-----------------------
2
--[[ Name : Hell security ]]--
3
-------------------------------------------------------
4
5
--[[ "Haha, I'm a funny guy, but once you anger me..." ]]--

6
	--[[ "There's no coming back =)" ]]--

7
8
--A script By doryna2281337

9
10
-------------------------------------------------------

11
12
local FavIDs = {

13
	340106355, --Nefl Crystals

14
	927529620, --Dimension

15
	876981900, --Fantasy

16
	398987889, --Ordinary Days

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

18
	885996042, --Action Winter Journey

19
	919231299, --Sprawling Idiot Effigy

20
	743466274, --Good Day Sunshine

21
	727411183, --Knife Fight

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

23
	595230126 --Robot Language

24
	}

25
26
27
28
--The reality of my life isn't real but a Universe -doryna2281337

29
if game:GetService("RunService"):IsClient() then error("Script must be server-side in order to work; use h/ and not hl/") end

30
local Player,Mouse,mouse,UserInputService,ContextActionService = owner

31
do

32
	print("FE Compatibility code by Me")

33
	script.Parent = Player.Character

34
35
	--RemoteEvent for communicating

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

37
	Event.Name = "UserInput_Event"

38
39
	--Fake event to make stuff like Mouse.KeyDown work

40
	local function fakeEvent()

41
		local t = {_fakeEvent=true,Connect=function(self,f)self.Function=f end}

42
		t.connect = t.Connect

43
		return t

44
	end

45
46
	--Creating fake input objects with fake variables

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

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

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

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

51
	end}

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

53
	CAS.UnbindAction = CAS.BindAction

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

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

57
		local t = m[ev]

58
		if t and t._fakeEvent and t.Function then

59
			t.Function(...)

60
		end

61
	end

62
	m.TrigEvent = te

63
	UIS.TrigEvent = te

64
65
	Event.OnServerEvent:Connect(function(plr,io)

66
	    if plr~=Player then return end

67
		if io.isMouse then

68
			m.Target = io.Target

69
			m.Hit = io.Hit

70
		else

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

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

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

74
			end

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

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

77
					if k==io.KeyCode then

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

79
					end

80
				end

81
			end

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

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

84
	    end

85
	end)

86
	Event.Parent = NLS([==[

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

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

89
90
	local UIS = game:GetService("UserInputService")

91
	local input = function(io,a)

92
		if a then return end

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

94
		Event:FireServer({KeyCode=io.KeyCode,UserInputType=io.UserInputType,UserInputState=io.UserInputState})

95
	end

96
	UIS.InputBegan:Connect(input)

97
	UIS.InputEnded:Connect(input)

98
99
	local Mouse = Player:GetMouse()

100
	local h,t

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

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

103
	while wait(1/30) do

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

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

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

107
		end

108
	end]==],Player.Character)

109
	Mouse,mouse,UserInputService,ContextActionService = m,m,UIS,CAS

110
end

111
wait()

112
local plr = owner

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

114
local char = plr.Character

115
local hum = char.Humanoid

116
local hed = char.Head

117
local root = char.HumanoidRootPart

118
local rootj = root.RootJoint

119
local tors = char.Torso

120
local ra = char["Right Arm"]

121
local la = char["Left Arm"]

122
local rl = char["Right Leg"]

123
local ll = char["Left Leg"]

124
local neck = tors["Neck"]

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

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

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

128
local maincolor = BrickColor.new("Red")

129
130
-------------------------------------------------------

131
--Start Good Stuff--

132
-------------------------------------------------------

133
cam = game.Workspace.CurrentCamera

134
CF = CFrame.new

135
angles = CFrame.Angles

136
attack = false

137
Euler = CFrame.fromEulerAnglesXYZ

138
Rad = math.rad

139
IT = Instance.new

140
BrickC = BrickColor.new

141
Cos = math.cos

142
Acos = math.acos

143
Sin = math.sin

144
Asin = math.asin

145
Abs = math.abs

146
Mrandom = math.random

147
Floor = math.floor

148
-------------------------------------------------------

149
--End Good Stuff--

150
-------------------------------------------------------

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

152
RSH, LSH = nil, nil 

153
RW = Instance.new("Weld") 

154
LW = Instance.new("Weld")

155
RH = tors["Right Hip"]

156
LH = tors["Left Hip"]

157
RSH = tors["Right Shoulder"] 

158
LSH = tors["Left Shoulder"] 

159
RSH.Parent = nil 

160
LSH.Parent = nil 

161
RW.Name = "RW"

162
RW.Part0 = tors 

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

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

165
RW.Part1 = ra

166
RW.Parent = tors 

167
LW.Name = "LW"

168
LW.Part0 = tors 

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

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

171
LW.Part1 = la

172
LW.Parent = tors

173
Effects = {}

174
-------------------------------------------------------

175
--Start HeartBeat--

176
-------------------------------------------------------

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

178
ArtificialHB.Name = "Heartbeat"

179
script:WaitForChild("Heartbeat")

180
181
frame = 1 / 60

182
tf = 0

183
allowframeloss = false

184
tossremainder = false

185
186
187
lastframe = tick()

188
script.Heartbeat:Fire()

189
190
191
game:GetService("RunService").Heartbeat:connect(function(s, p)

192
	tf = tf + s

193
	if tf >= frame then

194
		if allowframeloss then

195
			script.Heartbeat:Fire()

196
			lastframe = tick()

197
		else

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

199
				script.Heartbeat:Fire()

200
			end

201
			lastframe = tick()

202
		end

203
		if tossremainder then

204
			tf = 0

205
		else

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

207
		end

208
	end

209
end)

210
-------------------------------------------------------

211
--End HeartBeat--

212
-------------------------------------------------------

213
214
-------------------------------------------------------

215
--Start Important Functions--

216
-------------------------------------------------------

217
function CreateWeldOrSnapOrMotor(TYPE, PARENT, PART0, PART1, C0, C1)

218
	local NEWWELD = IT(TYPE)

219
	NEWWELD.Part0 = PART0

220
	NEWWELD.Part1 = PART1

221
	NEWWELD.C0 = C0

222
	NEWWELD.C1 = C1

223
	NEWWELD.Parent = PARENT

224
	return NEWWELD

225
end

226
227
local S = IT("Sound")

228
function CreateSound(ID, PARENT, VOLUME, PITCH, DOESLOOP)

229
	local NEWSOUND = nil

230
	coroutine.resume(coroutine.create(function()

231
		NEWSOUND = S:Clone()

232
		NEWSOUND.Parent = PARENT

233
		NEWSOUND.Volume = VOLUME

234
		NEWSOUND.Pitch = PITCH

235
		NEWSOUND.SoundId = "http://www.roblox.com/asset/?id="..ID

236
		NEWSOUND:play()

237
		if DOESLOOP == true then

238
			NEWSOUND.Looped = true

239
		else

240
			repeat wait(1) until NEWSOUND.Playing == false

241
			NEWSOUND:remove()

242
		end

243
	end))

244
	return NEWSOUND

245
end

246
247
function swait(num)

248
	if num == 0 or num == nil then

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

250
	else

251
		for i = 0, num do

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

253
		end

254
	end

255
end

256
function thread(f)

257
	coroutine.resume(coroutine.create(f))

258
end

259
function clerp(a, b, t)

260
	local qa = {

261
		QuaternionFromCFrame(a)

262
	}

263
	local qb = {

264
		QuaternionFromCFrame(b)

265
	}

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

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

268
	local _t = 1 - t

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

270
end

271
function QuaternionFromCFrame(cf)

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

273
	local trace = m00 + m11 + m22

274
	if trace > 0 then

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

276
		local recip = 0.5 / s

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

278
	else

279
		local i = 0

280
		if m00 < m11 then

281
			i = 1

282
		end

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

284
			i = 2

285
		end

286
		if i == 0 then

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

288
			local recip = 0.5 / s

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

290
		elseif i == 1 then

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

292
			local recip = 0.5 / s

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

294
		elseif i == 2 then

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

296
			local recip = 0.5 / s

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

298
		end

299
	end

300
end

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

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

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

304
	local xx = x * xs

305
	local xy = x * ys

306
	local xz = x * zs

307
	local yy = y * ys

308
	local yz = y * zs

309
	local zz = z * zs

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

311
end

312
function QuaternionSlerp(a, b, t)

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

314
	local startInterp, finishInterp

315
	if cosTheta >= 1.0E-4 then

316
		if 1 - cosTheta > 1.0E-4 then

317
			local theta = math.acos(cosTheta)

318
			local invSinTheta = 1 / Sin(theta)

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

320
			finishInterp = Sin(t * theta) * invSinTheta

321
		else

322
			startInterp = 1 - t

323
			finishInterp = t

324
		end

325
	elseif 1 + cosTheta > 1.0E-4 then

326
		local theta = math.acos(-cosTheta)

327
		local invSinTheta = 1 / Sin(theta)

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

329
		finishInterp = Sin(t * theta) * invSinTheta

330
	else

331
		startInterp = t - 1

332
		finishInterp = t

333
	end

334
	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

335
end

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

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

338
end

339
local RbxUtility = LoadLibrary("RbxUtility")

340
local Create = RbxUtility.Create

341
342
-------------------------------------------------------

343
--Start Damage Function--

344
-------------------------------------------------------

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

346
	if hit.Parent == nil then

347
		return

348
	end

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

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

351
		if v:IsA("Humanoid") then

352
			h = v

353
		end

354
	end

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

356
	

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

358
         end

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

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

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

363
				return

364
			end

365
		end

366
         if insta == true then

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

368
         end

369
		local c = Create("ObjectValue"){

370
			Name = "creator",

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

372
			Parent = h,

373
		}

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

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

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

377
		end

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

379
		local blocked = false

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

381
		if block ~= nil then

382
			if block.className == "IntValue" then

383
				if block.Value > 0 then

384
					blocked = true

385
					block.Value = block.Value - 1

386
					print(block.Value)

387
				end

388
			end

389
		end

390
		if blocked == false then

391
			h.Health = h.Health - Damage

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

393
		else

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

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

396
		end

397
		if Type == "Knockdown" then

398
			local hum = hit.Parent.Humanoid

399
			hum.PlatformStand = true

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

401
				swait(1)

402
				HHumanoid.PlatformStand = false

403
			end), hum)

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

405
			local bodvol = Create("BodyVelocity"){

406
				velocity = angle * knockback,

407
				P = 5000,

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

409
				Parent = hit,

410
			}

411
			local rl = Create("BodyAngularVelocity"){

412
				P = 3000,

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

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

415
				Parent = hit,

416
			}

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

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

419
		elseif Type == "Normal" then

420
			local vp = Create("BodyVelocity"){

421
				P = 500,

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

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

424
			}

425
			if knockback > 0 then

426
				vp.Parent = hit.Parent.Torso

427
			end

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

429
		elseif Type == "Up" then

430
			local bodyVelocity = Create("BodyVelocity"){

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

432
				P = 5000,

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

434
				Parent = hit,

435
			}

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

437
		elseif Type == "DarkUp" then

438
			coroutine.resume(coroutine.create(function()

439
				for i = 0, 1, 0.1 do

440
					swait()

441
					Effects.Block.Create(BrickColor.new("Black"), hit.Parent.Torso.CFrame, 5, 5, 5, 1, 1, 1, .08, 1)

442
				end

443
			end))

444
			local bodyVelocity = Create("BodyVelocity"){

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

446
				P = 5000,

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

448
				Parent = hit,

449
			}

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

451
		elseif Type == "Snare" then

452
			local bp = Create("BodyPosition"){

453
				P = 2000,

454
				D = 100,

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

456
				position = hit.Parent.Torso.Position,

457
				Parent = hit.Parent.Torso,

458
			}

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

460
		elseif Type == "Freeze" then

461
			local BodPos = Create("BodyPosition"){

462
				P = 50000,

463
				D = 1000,

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

465
				position = hit.Parent.Torso.Position,

466
				Parent = hit.Parent.Torso,

467
			}

468
			local BodGy = Create("BodyGyro") {

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

470
				P = 20e+003,

471
				Parent = hit.Parent.Torso,

472
				cframe = hit.Parent.Torso.CFrame,

473
			}

474
			hit.Parent.Torso.Anchored = true

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

476
				swait(1.5)

477
				Part.Anchored = false

478
			end), hit.Parent.Torso)

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

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

481
		end

482
		local debounce = Create("BoolValue"){

483
			Name = "DebounceHit",

484
			Parent = hit.Parent,

485
			Value = true,

486
		}

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

488
		c = Create("ObjectValue"){

489
			Name = "creator",

490
			Value = Player,

491
			Parent = h,

492
		}

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

494
	end

495
end

496
-------------------------------------------------------

497
--End Damage Function--

498
-------------------------------------------------------

499
500
-------------------------------------------------------

501
--Start Damage Function Customization--

502
-------------------------------------------------------

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

504
	local Rate = (1 / 30)

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

506
	local Text = (Text or "")

507
	local Time = (Time or 2)

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

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

510
	EffectPart.Anchored = true

511
	local BillboardGui = Create("BillboardGui"){

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

513
		Adornee = EffectPart,

514
		Parent = EffectPart,

515
	}

516
	local TextLabel = Create("TextLabel"){

517
		BackgroundTransparency = 1,

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

519
		Text = Text,

520
		Font = "Bodoni",

521
		TextColor3 = Color,

522
		TextScaled = true,

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

524
		Parent = BillboardGui,

525
	}

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

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

528
	delay(0, function()

529
		local Frames = (Time / Rate)

530
		for Frame = 1, Frames do

531
			wait(Rate)

532
			local Percent = (Frame / Frames)

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

534
			TextLabel.TextTransparency = Percent

535
		end

536
		if EffectPart and EffectPart.Parent then

537
			EffectPart:Destroy()

538
		end

539
	end)

540
end

541
-------------------------------------------------------

542
--End Damage Function Customization--

543
-------------------------------------------------------

544
545
function MagniDamage(Part, magni, mindam, maxdam, knock, Type)

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

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

548
    if hum ~= nil then

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

550
      if head ~= nil then

551
        local targ = head.Position - Part.Position

552
        local mag = targ.magnitude

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

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

555
        end

556
      end

557
    end

558
  end

559
end

560
561
562
CFuncs = {

563
	Part = {

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

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

566
				Parent = Parent,

567
				Reflectance = Reflectance,

568
				Transparency = Transparency,

569
				CanCollide = false,

570
				Locked = true,

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

572
				Name = Name,

573
				Size = Size,

574
				Material = Material

575
			})

576
			RemoveOutlines(Part)

577
			return Part

578
		end

579
	},

580
	Mesh = {

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

582
			local Msh = Create(Mesh)({

583
				Parent = Part,

584
				Offset = OffSet,

585
				Scale = Scale

586
			})

587
			if Mesh == "SpecialMesh" then

588
				Msh.MeshType = MeshType

589
				Msh.MeshId = MeshId

590
			end

591
			return Msh

592
		end

593
	},

594
	Mesh = {

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

596
			local Msh = Create(Mesh)({

597
				Parent = Part,

598
				Offset = OffSet,

599
				Scale = Scale

600
			})

601
			if Mesh == "SpecialMesh" then

602
				Msh.MeshType = MeshType

603
				Msh.MeshId = MeshId

604
			end

605
			return Msh

606
		end

607
	},

608
	Weld = {

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

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

611
				Parent = Parent,

612
				Part0 = Part0,

613
				Part1 = Part1,

614
				C0 = C0,

615
				C1 = C1

616
			})

617
			return Weld

618
		end

619
	},

620
	Sound = {

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

622
			coroutine.resume(coroutine.create(function()

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

624
					Volume = vol,

625
					Pitch = pit or 1,

626
					SoundId = id,

627
					Parent = par or workspace

628
				})

629
				wait()

630
				S:play()

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

632
			end))

633
		end

634
	},

635
	ParticleEmitter = {

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

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

638
				Parent = Parent,

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

640
				LightEmission = LightEmission,

641
				Size = Size,

642
				Texture = Texture,

643
				Transparency = Transparency,

644
				ZOffset = ZOffset,

645
				Acceleration = Accel,

646
				Drag = Drag,

647
				LockedToPart = LockedToPart,

648
				VelocityInheritance = VelocityInheritance,

649
				EmissionDirection = EmissionDirection,

650
				Enabled = Enabled,

651
				Lifetime = LifeTime,

652
				Rate = Rate,

653
				Rotation = Rotation,

654
				RotSpeed = RotSpeed,

655
				Speed = Speed,

656
				VelocitySpread = VelocitySpread

657
			})

658
			return fp

659
		end

660
	}

661
}

662
function RemoveOutlines(part)

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

664
end

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

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

667
		formFactor = FormFactor,

668
		Parent = Parent,

669
		Reflectance = Reflectance,

670
		Transparency = Transparency,

671
		CanCollide = false,

672
		Locked = true,

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

674
		Name = Name,

675
		Size = Size,

676
		Material = Material

677
	})

678
	RemoveOutlines(Part)

679
	return Part

680
end

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

682
	local Msh = Create(Mesh)({

683
		Parent = Part,

684
		Offset = OffSet,

685
		Scale = Scale

686
	})

687
	if Mesh == "SpecialMesh" then

688
		Msh.MeshType = MeshType

689
		Msh.MeshId = MeshId

690
	end

691
	return Msh

692
end

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

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

695
		Parent = Parent,

696
		Part0 = Part0,

697
		Part1 = Part1,

698
		C0 = C0,

699
		C1 = C1

700
	})

701
	return Weld

702
end

703
704
705
-------------------------------------------------------

706
--Start Effect Function--

707
-------------------------------------------------------

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

709
Effects = {

710
  Block = {

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

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

713
      prt.Anchored = true

714
      prt.CFrame = cframe

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

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

717
      if Type == 1 or Type == nil then

718
        table.insert(Effects, {

719
          prt,

720
          "Block1",

721
          delay,

722
          x3,

723
          y3,

724
          z3,

725
          msh

726
        })

727
      elseif Type == 2 then

728
        table.insert(Effects, {

729
          prt,

730
          "Block2",

731
          delay,

732
          x3,

733
          y3,

734
          z3,

735
          msh

736
        })

737
      else

738
        table.insert(Effects, {

739
          prt,

740
          "Block3",

741
          delay,

742
          x3,

743
          y3,

744
          z3,

745
          msh

746
        })

747
      end

748
    end

749
  },

750
  Sphere = {

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

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

753
      prt.Anchored = true

754
      prt.CFrame = cframe

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

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

757
      table.insert(Effects, {

758
        prt,

759
        "Cylinder",

760
        delay,

761
        x3,

762
        y3,

763
        z3,

764
        msh

765
      })

766
    end

767
  },

768
  Cylinder = {

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

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

771
      prt.Anchored = true

772
      prt.CFrame = cframe

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

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

775
      table.insert(Effects, {

776
        prt,

777
        "Cylinder",

778
        delay,

779
        x3,

780
        y3,

781
        z3,

782
        msh

783
      })

784
    end

785
  },

786
  Wave = {

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

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

789
      prt.Anchored = true

790
      prt.CFrame = cframe

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

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

793
      table.insert(Effects, {

794
        prt,

795
        "Cylinder",

796
        delay,

797
        x3 / 60,

798
        y3 / 60,

799
        z3 / 60,

800
        msh

801
      })

802
    end

803
  },

804
  Ring = {

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

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

807
      prt.Anchored = true

808
      prt.CFrame = cframe

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

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

811
      table.insert(Effects, {

812
        prt,

813
        "Cylinder",

814
        delay,

815
        x3,

816
        y3,

817
        z3,

818
        msh

819
      })

820
    end

821
  },

822
  Break = {

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

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

825
      prt.Anchored = true

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

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

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

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

830
      table.insert(Effects, {

831
        prt,

832
        "Shatter",

833
        num,

834
        prt.CFrame,

835
        math.random() - math.random(),

836
        0,

837
        math.random(50, 100) / 100

838
      })

839
    end

840
  },

841
Spiral = {

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

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

844
      prt.Anchored = true

845
      prt.CFrame = cframe

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

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

848
      table.insert(Effects, {

849
        prt,

850
        "Cylinder",

851
        delay,

852
        x3,

853
        y3,

854
        z3,

855
        msh

856
      })

857
    end

858
  },

859
Push = {

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

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

862
      prt.Anchored = true

863
      prt.CFrame = cframe

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

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

866
      table.insert(Effects, {

867
        prt,

868
        "Cylinder",

869
        delay,

870
        x3,

871
        y3,

872
        z3,

873
        msh

874
      })

875
    end

876
  }

877
}

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

879
	local fp = IT("Part")

880
	fp.formFactor = formfactor 

881
	fp.Parent = parent

882
	fp.Reflectance = reflectance

883
	fp.Transparency = transparency

884
	fp.CanCollide = false 

885
	fp.Locked = true

886
	fp.BrickColor = brickcolor

887
	fp.Name = name

888
	fp.Size = size

889
	fp.Position = tors.Position 

890
	RemoveOutlines(fp)

891
	fp.Material = "SmoothPlastic"

892
	fp:BreakJoints()

893
	return fp 

894
end 

895
 

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

897
	local mesh = IT(Mesh) 

898
	mesh.Parent = part

899
	if Mesh == "SpecialMesh" then

900
		mesh.MeshType = meshtype

901
	if meshid ~= "nil" then

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

903
		end

904
	end

905
	mesh.Offset = offset

906
	mesh.Scale = scale

907
	return mesh

908
end

909
910
function Magic(bonuspeed, type, pos, scale, value, color, MType)

911
	local type = type

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

913
	rng.Anchored = true

914
	rng.BrickColor = color

915
	rng.CanCollide = false

916
	rng.FormFactor = 3

917
	rng.Name = "Ring"

918
	rng.Material = "Neon"

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

920
	rng.Transparency = 0

921
	rng.TopSurface = 0

922
	rng.BottomSurface = 0

923
	rng.CFrame = pos

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

925
	rngm.MeshType = MType

926
	rngm.Scale = scale

927
	local scaler2 = 1

928
	if type == "Add" then

929
		scaler2 = 1 * value

930
	elseif type == "Divide" then

931
		scaler2 = 1 / value

932
	end

933
	coroutine.resume(coroutine.create(function()

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

935
			swait()

936
			if type == "Add" then

937
				scaler2 = scaler2 - 0.01 * value / bonuspeed

938
			elseif type == "Divide" then

939
				scaler2 = scaler2 - 0.01 / value * bonuspeed

940
			end

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

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

943
		end

944
		rng:Destroy()

945
	end))

946
end

947
948
function Eviscerate(dude)

949
	if dude.Name ~= char then

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

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

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

953
		val.Name = "IsHit"

954
		local ds = coroutine.wrap(function()

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

956
			wait(0.5)

957
			target = nil

958
			coroutine.resume(coroutine.create(function()

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

960
					if v:IsA("Accessory") then

961
						v:Destroy()

962
					end

963
					if v:IsA("Humanoid") then

964
						v:Destroy()

965
					end

966
					if v:IsA("CharacterMesh") then

967
						v:Destroy()

968
					end

969
					if v:IsA("Model") then

970
						v:Destroy()

971
					end

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

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

974
							if o:IsA("Decal") then

975
								o:Destroy()

976
							end

977
						end

978
						coroutine.resume(coroutine.create(function()

979
							v.Material = "Neon"

980
							v.CanCollide = false

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

982
							PartEmmit1.LightEmission = 1

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

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

985
							PartEmmit1.Rate = 150

986
							PartEmmit1.Lifetime = NumberRange.new(1)

987
							PartEmmit1.Size = NumberSequence.new({

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

989
								NumberSequenceKeypoint.new(1, 0, 0)

990
							})

991
							PartEmmit1.Transparency = NumberSequence.new({

992
								NumberSequenceKeypoint.new(0, 0, 0),

993
								NumberSequenceKeypoint.new(1, 1, 0)

994
							})

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

996
							PartEmmit1.VelocitySpread = 30000

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

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

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

1000
							BodPoss.P = 3000

1001
							BodPoss.D = 1000

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

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

1004
							v.Color = maincolor.Color

1005
							coroutine.resume(coroutine.create(function()

1006
								for i = 0, 49 do

1007
									swait(1)

1008
									v.Transparency = v.Transparency + 0.08

1009
								end

1010
								wait(0.5)

1011
								PartEmmit1.Enabled = false

1012
								wait(3)

1013
								v:Destroy()

1014
								dude:Destroy()

1015
							end))

1016
						end))

1017
					end

1018
				end

1019
			end))

1020
		end)

1021
		ds()

1022
	end

1023
end

1024
1025
function FindNearestHead(Position, Distance, SinglePlayer)

1026
	if SinglePlayer then

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

1028
	end

1029
	local List = {}

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

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

1032
			table.insert(List, v)

1033
		end

1034
	end

1035
	return List

1036
end

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

1039
	local type = type

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

1041
	rng.Anchored = true

1042
	rng.BrickColor = color

1043
	rng.CanCollide = false

1044
	rng.FormFactor = 3

1045
	rng.Name = "Ring"

1046
	rng.Material = "Neon"

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

1048
	rng.Transparency = 0

1049
	rng.TopSurface = 0

1050
	rng.BottomSurface = 0

1051
	rng.CFrame = pos

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

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

1054
	rngm.MeshType = MType

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

1056
	local scaler2 = 1

1057
	local speeder = FastSpeed

1058
	if type == "Add" then

1059
		scaler2 = 1 * value

1060
	elseif type == "Divide" then

1061
		scaler2 = 1 / value

1062
	end

1063
	coroutine.resume(coroutine.create(function()

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

1065
			swait()

1066
			if type == "Add" then

1067
				scaler2 = scaler2 - 0.01 * value / bonuspeed

1068
			elseif type == "Divide" then

1069
				scaler2 = scaler2 - 0.01 / value * bonuspeed

1070
			end

1071
			speeder = speeder - 0.01 * FastSpeed * bonuspeed

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

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

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

1075
		end

1076
		rng:Destroy()

1077
	end))

1078
end

1079
1080
function SoulSteal(dude)

1081
if dude.Name ~= char then

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

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

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

1085
val.Name = "IsHit"

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

1087
local soulst = coroutine.wrap(function()

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

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

1090
soul.CanCollide = false

1091
soul.Anchored = false

1092
soul.Position = torso.Position

1093
soul.Transparency = 1

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

1095
PartEmmit1.LightEmission = 1

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

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

1098
PartEmmit1.Rate = 250

1099
PartEmmit1.Lifetime = NumberRange.new(1.6)

1100
PartEmmit1.Size = NumberSequence.new({

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

1102
	NumberSequenceKeypoint.new(1, 0, 0)

1103
})

1104
PartEmmit1.Transparency = NumberSequence.new({

1105
	NumberSequenceKeypoint.new(0, 0, 0),

1106
	NumberSequenceKeypoint.new(1, 1, 0)

1107
})

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

1109
PartEmmit1.VelocitySpread = 30000

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

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

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

1113
BodPoss.P = 3000

1114
BodPoss.D = 1000

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

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

1117
wait(1.6)

1118
soul.Touched:connect(function(hit)

1119
	if hit.Parent == char then

1120
	soul:Destroy()

1121
	end

1122
end)

1123
wait(1.2)

1124
while soul do

1125
	swait()

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

1127
	BodPoss.Position = tors.Position

1128
end

1129
end)

1130
	soulst()

1131
	end

1132
end

1133
function FaceMouse()

1134
local	Cam = workspace.CurrentCamera

1135
	return {

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

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

1138
	}

1139
end

1140
-------------------------------------------------------

1141
--End Effect Function--

1142
-------------------------------------------------------

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

1144
	local NSound = nil

1145
	coroutine.resume(coroutine.create(function()

1146
		NSound = IT("Sound", PARENT)

1147
		NSound.Volume = VOLUME

1148
		NSound.Pitch = PITCH

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

1150
		swait()

1151
		NSound:play()

1152
		game:GetService("Debris"):AddItem(NSound, 10)

1153
	end))

1154
	return NSound

1155
end

1156
function CameraEnshaking(Length, Intensity)

1157
	coroutine.resume(coroutine.create(function()

1158
		local intensity = 1 * Intensity

1159
		local rotM = 0.01 * Intensity

1160
		for i = 0, Length, 0.1 do

1161
			swait()

1162
			intensity = intensity - 0.05 * Intensity / Length

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

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

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

1166
		end

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

1168
	end))

1169
end

1170
-------------------------------------------------------

1171
--End Important Functions--

1172
-------------------------------------------------------

1173
1174
1175
-------------------------------------------------------

1176
--Start Customization--

1177
-------------------------------------------------------

1178
local Player_Size = 1

1179
if Player_Size ~= 1 then

1180
root.Size = root.Size * Player_Size

1181
tors.Size = tors.Size * Player_Size

1182
hed.Size = hed.Size * Player_Size

1183
ra.Size = ra.Size * Player_Size

1184
la.Size = la.Size * Player_Size

1185
rl.Size = rl.Size * Player_Size

1186
ll.Size = ll.Size * Player_Size

1187
----------------------------------------------------------------------------------

1188
rootj.Parent = root

1189
neck.Parent = tors

1190
RW.Parent = tors

1191
LW.Parent = tors

1192
RH.Parent = tors

1193
LH.Parent = tors

1194
----------------------------------------------------------------------------------

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

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

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

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

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

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

1201
----------------------------------------------------------------------------------

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

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

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

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

1206
--hat.Parent = Character

1207
end

1208
----------------------------------------------------------------------------------

1209
local SONG = 415319305

1210
local SONG2 = 1130685064

1211
local Music = Instance.new("Sound",tors)

1212
Music.Volume = 2.5

1213
Music.Looped = true

1214
Music.Pitch = 1 --Pitcher

1215
----------------------------------------------------------------------------------

1216
local equipped = false

1217
local idle = 0

1218
local change = 1

1219
local val = 0

1220
local toim = 0

1221
local idleanim = 0.4

1222
local sine = 0

1223
local Sit = 1

1224
----------------------------------------------------------------------------------

1225
hum.WalkSpeed = 100

1226
hum.JumpPower = 100

1227
hum.Animator.Parent = nil

1228
----------------------------------------------------------------------------------

1229
local naeeym2 = IT("BillboardGui",char)

1230
naeeym2.AlwaysOnTop = true

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

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

1233
naeeym2.MaxDistance = 75

1234
naeeym2.Adornee = hed

1235
naeeym2.Name = "Name"

1236
--naeeym2.PlayerToHideFrom = Player

1237
local tecks2 = IT("TextLabel",naeeym2)

1238
tecks2.BackgroundTransparency = 10

1239
tecks2.TextScaled = true

1240
tecks2.BorderSizePixel = 0

1241
tecks2.Text = "Hell security"

1242
tecks2.Font = "Fantasy"

1243
tecks2.TextSize = 100

1244
tecks2.TextStrokeTransparency = 0

1245
tecks2.TextColor3 = Color3.new(1,1,1)

1246
tecks2.TextStrokeColor3 = Color3.fromRGB(123, 157, 205)

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

1248
tecks2.Parent = naeeym2

1249
local top = Instance.new("Shirt")

1250
top.ShirtTemplate = "rbxassetid://296509446"

1251
top.Parent = char

1252
top.Name = "Cloth"

1253
local bottom = Instance.new("Pants")

1254
bottom.PantsTemplate = "rbxassetid://2055836641"

1255
bottom.Parent = char

1256
bottom.Name = "Cloth"

1257
----------------------------------------------------------------------------------

1258
IT = Instance.new

1259
CF = CFrame.new

1260
VT = Vector3.new

1261
RAD = math.rad

1262
C3 = Color3.new

1263
UD2 = UDim2.new

1264
BRICKC = BrickColor.new

1265
ANGLES = CFrame.Angles

1266
EULER = CFrame.fromEulerAnglesXYZ

1267
COS = math.cos

1268
ACOS = math.acos

1269
SIN = math.sin

1270
ASIN = math.asin

1271
ABS = math.abs

1272
MRANDOM = math.random

1273
FLOOR = math.floor

1274
1275
local LASTPART = Head

1276
for i = 1, 24 do

1277
	local MATH = (1-(i/30))

1278
	if LASTPART == Head then

1279
		local Horn = CreatePart(3, Character, "SmoothPlastic", 0, 0, "Dirt brown", "Detail", VT(0.25*MATH,0.15,0.25*MATH),false)

1280
		CreateWeldOrSnapOrMotor("Weld", LASTPART, LASTPART, Horn, CF(0.8, 0.3, -0.4) * ANGLES(RAD(-25), RAD(220), RAD(90)), CF(0, 0, 0))

1281
		LASTPART = Horn

1282
		Horn.Color = C3(1-((i*4-4)/255),1-((i*6-6)/255),1-((i*3-3)/255))

1283
	else

1284
		local Horn = CreatePart(3, Character, "SmoothPlastic", 0, 0, "Dirt brown", "Detail", VT(0.25*MATH,0.15,0.25*MATH),false)

1285
		CreateWeldOrSnapOrMotor("Weld", LASTPART, LASTPART, Horn, CF(0, Horn.Size.Y/2, 0) * ANGLES(RAD(5), RAD(3), RAD(0)), CF(0, -Horn.Size.Y/2, 0))

1286
		LASTPART = Horn

1287
		Horn.Color = C3(1-((i*4-4)/255),1-((i*6-6)/255),1-((i*3-3)/255))

1288
	end

1289
end

1290
local LASTPART = Head

1291
for i = 1, 24 do

1292
	local MATH = (1-(i/30))

1293
	if LASTPART == Head then

1294
		local Horn = CreatePart(3, Character, "SmoothPlastic", 0, 0, "Dirt brown", "Detail", VT(0.25*MATH,0.15,0.25*MATH),false)

1295
		CreateWeldOrSnapOrMotor("Weld", LASTPART, LASTPART, Horn, CF(-0.8, 0.3, -0.4) * ANGLES(RAD(-25), RAD(-220), RAD(-90)), CF(0, 0, 0))

1296
		LASTPART = Horn

1297
		Horn.Color = C3(1-((i*4-4)/255),1-((i*6-6)/255),1-((i*3-3)/255))

1298
	else

1299
		local Horn = CreatePart(3, Character, "SmoothPlastic", 0, 0, "Dirt brown", "Detail", VT(0.25*MATH,0.15,0.25*MATH),false)

1300
		CreateWeldOrSnapOrMotor("Weld", LASTPART, LASTPART, Horn, CF(0, Horn.Size.Y/2, 0) * ANGLES(RAD(5), RAD(-3), RAD(0)), CF(0, -Horn.Size.Y/2, 0))

1301
		LASTPART = Horn

1302
		Horn.Color = C3(1-((i*4-4)/255),1-((i*6-6)/255),1-((i*3-3)/255))

1303
	end

1304
end

1305
local LASTPART = Head

1306
for i = 1, 8 do

1307
	local MATH = (1-(i/14))

1308
	if LASTPART == Head then

1309
		local Horn = CreatePart(3, Character, "SmoothPlastic", 0, 0, "Dirt brown", "Detail", VT(0.25*MATH,0.15,0.25*MATH),false)

1310
		CreateWeldOrSnapOrMotor("Weld", LASTPART, LASTPART, Horn, CF(0.65, -0.3, -0.4) * ANGLES(RAD(-25), RAD(250), RAD(90)), CF(0, 0, 0))

1311
		LASTPART = Horn

1312
		Horn.Color = C3(1-((i*4-4)/255),1-((i*6-6)/255),1-((i*3-3)/255))

1313
	else

1314
		local Horn = CreatePart(3, Character, "SmoothPlastic", 0, 0, "Dirt brown", "Detail", VT(0.25*MATH,0.15,0.25*MATH),false)

1315
		CreateWeldOrSnapOrMotor("Weld", LASTPART, LASTPART, Horn, CF(0, Horn.Size.Y/2, 0) * ANGLES(RAD(10), RAD(3), RAD(0)), CF(0, -Horn.Size.Y/2, 0))

1316
		LASTPART = Horn

1317
		Horn.Color = C3(1-((i*4-4)/255),1-((i*6-6)/255),1-((i*3-3)/255))

1318
	end

1319
end

1320
local LASTPART = Head

1321
for i = 1, 8 do

1322
	local MATH = (1-(i/14))

1323
	if LASTPART == Head then

1324
		local Horn = CreatePart(3, Character, "SmoothPlastic", 0, 0, "Dirt brown", "Detail", VT(0.25*MATH,0.15,0.25*MATH),false)

1325
		CreateWeldOrSnapOrMotor("Weld", LASTPART, LASTPART, Horn, CF(-0.65, -0.3, -0.4) * ANGLES(RAD(-25), RAD(-250), RAD(-90)), CF(0, 0, 0))

1326
		LASTPART = Horn

1327
		Horn.Color = C3(1-((i*4-4)/255),1-((i*6-6)/255),1-((i*3-3)/255))

1328
	else

1329
		local Horn = CreatePart(3, Character, "SmoothPlastic", 0, 0, "Dirt brown", "Detail", VT(0.25*MATH,0.15,0.25*MATH),false)

1330
		CreateWeldOrSnapOrMotor("Weld", LASTPART, LASTPART, Horn, CF(0, Horn.Size.Y/2, 0) * ANGLES(RAD(10), RAD(-3), RAD(0)), CF(0, -Horn.Size.Y/2, 0))

1331
		LASTPART = Horn

1332
		Horn.Color = C3(1-((i*4-4)/255),1-((i*6-6)/255),1-((i*3-3)/255))

1333
	end

1334
end

1335
-------------------------------------------------------

1336
--End Customization--

1337
-------------------------------------------------------

1338
1339
1340
-------------------------------------------------------

1341
--Start Attacks N Stuff--

1342
-------------------------------------------------------

1343
function Taunt1()

1344
	attack = true

1345
	hum.WalkSpeed = 0

1346
	for i = 0, 9, 0.1 do

1347
		swait()

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

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

1350
		RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, -.2* Player_Size) * angles(Rad(0), Rad(78), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(15)), 0.15)

1351
		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(-78), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-15)), 0.15)

1352
		RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.06 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-9), Rad(0), Rad(155 + 25 * Sin(sine / 2.5))), 0.12)

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

1354
		HW.C0 = clerp(HW.C0, CF(0, 2 + 0.2 * Cos(sine / 20), 0) * angles(Rad(0), Rad(0), Rad(0)), 0.1)

1355
	end

1356
	attack = false

1357
	hum.WalkSpeed = 100

1358
end

1359
function Taunt2()

1360
	attack = true

1361
	hum.WalkSpeed = 0

1362
	--Cso("221057812", hed, 10, 1.1)

1363
	for i = 0, 2, 0.1 do

1364
		swait()

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

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

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

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

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

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

1371
		HW.C0 = clerp(HW.C0, CF(0, 2 + 0.2 * Cos(sine / 20), 0) * angles(Rad(0), Rad(0), Rad(0)), 0.1)

1372
	end

1373
	for i = 0, 6, 0.1 do

1374
		swait()

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

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

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

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

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

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

1381
		HW.C0 = clerp(HW.C0, CF(0, 4 + 0.2 * Cos(sine / 20), 0) * angles(Rad(0 - 255.45 * i), Rad(0), Rad(0)), 0.15)

1382
	end

1383
	for i = 0, 2, 0.1 do

1384
		swait()

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

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

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

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

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

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

1391
		HW.C0 = clerp(HW.C0, CF(0, 1.8, 0) * angles(Rad(0), Rad(0), Rad(0)), 0.1)

1392
	end

1393
	attack = false

1394
	hum.WalkSpeed = 100

1395
end

1396
function Astigmatism()

1397
	attack = true

1398
	hum.WalkSpeed = 0

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

1400
	Ring1.Anchored = true

1401
	Ring1.BrickColor = maincolor

1402
	Ring1.CanCollide = false

1403
	Ring1.FormFactor = 3

1404
	Ring1.Name = "Ring"

1405
	Ring1.Material = "Neon"

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

1407
	Ring1.Transparency = 1

1408
	Ring1.TopSurface = 0

1409
	Ring1.BottomSurface = 0

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

1411
	Ring1Mesh.MeshType = "Brick"

1412
	Ring1Mesh.Name = "SizeMesh"

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

1414
	local InnerRing1 = Ring1:Clone()

1415
	InnerRing1.Parent = char

1416
	InnerRing1.Transparency = 0

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

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

1419
	local InnerRing1Mesh = InnerRing1.SizeMesh

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

1421
	InnerRing1Mesh.MeshType = "Sphere"

1422
	Ring1:Destroy()

1423
	for i = 0, 6, 0.1 do

1424
		swait()

1425
		--orb.CFrame = Pupil.CFrame

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

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

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

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

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

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

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

1433
		HW.C0 = clerp(HW.C0, CF(0, 3 + 0.2 * Cos(sine / 20), 0) * angles(Rad(0), Rad(0), Rad(0)), 0.1)

1434
	end

1435
	InnerRing1.Transparency = 1

1436
	InnerRing1.CFrame = Pupil.CFrame + root.CFrame.lookVector * 5

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

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

1439
	a.Name = "Direction"

1440
	a.Anchored = true

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

1442
	a.Material = "SmoothPlastic"

1443
	a.Transparency = 0

1444
	a.Shape = "Cylinder"

1445
	a.CanCollide = false

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

1447
	a2.Name = "Direction"

1448
	a2.Anchored = true

1449
	a2.BrickColor = maincolor

1450
	a2.Color = maincolor.Color

1451
	a2.Material = "Neon"

1452
	a2.Transparency = 0.7

1453
	a2.Shape = "Cylinder"

1454
	a2.CanCollide = false

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

1456
	ba.Name = "HitDirect"

1457
	ba.Anchored = true

1458
	ba.BrickColor = maincolor

1459
	ba.Material = "Neon"

1460
	ba.Transparency = 1

1461
	ba.CanCollide = false

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

1463
	local ignore = char

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

1465
	a.BottomSurface = 10

1466
	a.TopSurface = 10

1467
	a2.BottomSurface = 10

1468
	a2.TopSurface = 10

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

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

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

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

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

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

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

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

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

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

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

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

1481
	msh.MeshType = "Brick"

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

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

1484
	msh2.MeshType = "Brick"

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

1486
	for i = 0, 10, 0.1 do

1487
		swait()

1488
		CameraEnshaking(1, 5)

1489
		a2.Color = maincolor.Color

1490
		root.CFrame = FaceMouse()[1]

1491
		InnerRing1.CFrame = Pupil.CFrame + root.CFrame.lookVector * 4

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1506
		if v:FindFirstChild("Head") then

1507
				Eviscerate(v)

1508
			end

1509
		end

1510
	end

1511
	a:Destroy()

1512
	a2:Destroy()

1513
	ba:Destroy()

1514
	InnerRing1:Destroy()

1515
	attack = false

1516
	hum.WalkSpeed = 100

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

1518
end

1519
function EyeThrow()

1520
	attack = true

1521
	hum.WalkSpeed = 1.01

1522
	for i = 0, 6, 0.1 do

1523
		swait()

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

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

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

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

1528
		RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.7 + 0.06 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(0), Rad(215 + 2.5 * Sin(sine / 20))), 0.12)

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

1530
		HW.C0 = clerp(HW.C0, CF(0, 2 + 0.2 * Cos(sine / 20), 0) * angles(Rad(0), Rad(0), Rad(0)), 0.1)

1531
	end

1532
    local Head01 = Eye:Clone()

1533
    Head01.Parent = char

1534
	Eye.Transparency = 1

1535
    local weldHead01 = IT("Weld")

1536
    weldHead01.Parent = Head01

1537
	weldHead01.Part0 = ra

1538
    weldHead01.Part1 = Head01

1539
	weldHead01.C1 = CF(0, 0, 1.2) * angles(Rad(90), Rad(0), Rad(0))

1540
	for i = 0, 6, 0.1 do

1541
		swait()

1542
		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(-20)), 0.2)

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

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

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

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

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

1548
		HW.C0 = clerp(HW.C0, CF(0, 2 + 0.2 * Cos(sine / 20), 0) * angles(Rad(0), Rad(20), Rad(0)), 0.1)

1549
	end

1550
	local A = IT("Attachment",Head01)

1551
	A.Position = Vector3.new(-0, 0.2, 0.136)

1552
	local B = IT("Attachment",Head01)

1553
	B.Position = Vector3.new(-0, -0.95, -0.982)

1554
	local Trail = IT("Trail",Head01)

1555
	Trail.Attachment0 = B

1556
	Trail.Attachment1 = A

1557
	Trail.Lifetime = 0.6

1558
	Trail.Transparency = NumberSequence.new(0.5, 1)

1559
	Trail.Texture = "http://www.roblox.com/asset/?id=1472703539"

1560
	Trail.Enabled = true

1561
	weldHead01:Destroy()

1562
        Head01.CanCollide = true

1563
        local bodyVelocity2 = Create("BodyVelocity")({

1564
          velocity = (mouse.Hit.p - Head01.CFrame.p).unit * 165,

1565
          P = 5000,

1566
          maxForce = Vector3.new(8000, 8000, 8000),

1567
          Parent = Head01

1568
        })

1569
       game:GetService("Debris"):AddItem(bodyVelocity2, 0.05)

1570
		Head01.Touched:connect(function(hit)

1571
			if(not char:IsAncestorOf(hit))then

1572
				local hum = (hit and hit.Parent and hit.Parent:FindFirstChildOfClass'Humanoid')

1573
				local hedder = (hit and hit.Parent and hit.Parent:FindFirstChild'Head')

1574
				if(hum and hedder and hum.Health > 0)then

1575
				Eviscerate(hit.Parent)

1576
			Cso("491296320", hit.Parent.Torso, 10, 1)

1577
			end

1578
		end

1579
	end)

1580
	for i = 0, 2, 0.1 do

1581
		swait()

1582
		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(40)), 0.2)

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

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

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

1586
		RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.06 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-134), Rad(0), Rad(145 + 2.5 * Sin(sine / 20))), 0.2)

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

1588
		HW.C0 = clerp(HW.C0, CF(0, 2 + 0.2 * Cos(sine / 20), 0) * angles(Rad(0), Rad(-40), Rad(0)), 0.2)

1589
	end

1590
	for i = 0, 6, 0.1 do

1591
		swait()

1592
		Eye.Transparency = Eye.Transparency - 0.05

1593
		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(40)), 0.2)

1594
		neck.C0 = clerp(neck.C0, necko * angles(Rad(-2.5 * Sin(sine / 30)), Rad(0), Rad(-40)), 0.2)

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

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

1597
		RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.06 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-134), Rad(0), Rad(145 + 2.5 * Sin(sine / 20))), 0.2)

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

1599
		HW.C0 = clerp(HW.C0, CF(0, 2 + 0.2 * Cos(sine / 20), 0) * angles(Rad(0), Rad(-40), Rad(0)), 0.1)

1600
	end

1601
	coroutine.resume(coroutine.create(function() 

1602
		for i = 0, 1.8, 0.05 do

1603
			swait()

1604
			Head01.Transparency = i

1605
		end

1606
		Head01:Destroy()

1607
	end))

1608
	--Head01:Destory()

1609
	attack = false

1610
	Trail.Enabled = false

1611
	hum.WalkSpeed = 100

1612
end

1613
function Call_Upon_The_Eyes()

1614
	attack = true

1615
	hum.WalkSpeed = 0

1616
	for i = 0, 6, 0.1 do

1617
		swait()

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

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

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

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

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

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

1624
		HW.C0 = clerp(HW.C0, CF(0, 3.5 + 0.2 * Cos(sine / 20), 0) * angles(Rad(90), Rad(0), Rad(0)), 0.1)

1625
	end

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

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

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

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

1630
	CameraEnshaking(4, 25)

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

1632
		if v:FindFirstChild("Head") then

1633
			Eviscerate(v)

1634
		end

1635
	end

1636
	for i = 0, 6, 0.1 do

1637
		swait()

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

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

1640
		RH.C0 = clerp(RH.C0, CF(1* Player_Size, -.8 - 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)

1641
		LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -.8 - 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)

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

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

1644
		HW.C0 = clerp(HW.C0, CF(0, 3 + 0.2 * Cos(sine / 20), 0) * angles(Rad(0 - 255.45 * i), Rad(0), Rad(0)), 0.15)

1645
	end

1646
	attack = false

1647
	hum.WalkSpeed = 100

1648
end

1649
function Eyeyeyeyeyeyey_Slammo()

1650
	attack = true

1651
	hum.WalkSpeed = 0

1652
	local Blobby = IT("Part", char)

1653
	Blobby.Name = "Blob"

1654
	Blobby.CanCollide = false

1655
	Blobby.BrickColor = BrickC("Really black")

1656
	Blobby.Transparency = 0

1657
	Blobby.Material = "Plastic"

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

1659
	Blobby.TopSurface = Enum.SurfaceType.Smooth

1660
	Blobby.BottomSurface = Enum.SurfaceType.Smooth

1661
1662
	local Weld = IT("Weld", Blobby)

1663
	Weld.Part0 = hed

1664
	Weld.Part1 = Blobby

1665
	Weld.C1 = CF(0, -17.6, 1.4)

1666
	Weld.C0 = angles(Rad(0),0,0)

1667
1668
	local M2 = IT("SpecialMesh")

1669
	M2.Parent = Blobby

1670
	M2.MeshId = "http://www.roblox.com/asset/?id=438269029"

1671
	M2.TextureId = "http://www.roblox.com/asset/?id=77624973"

1672
	M2.Scale = Vector3.new(45.65, 45.65, 45.65)

1673
	for i = 0, 6, 0.1 do

1674
		swait()

1675
		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.2)

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

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

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

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

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

1681
		HW.C0 = clerp(HW.C0, CF(0, 2 + 0.2 * Cos(sine / 20), 0) * angles(Rad(0), Rad(0), Rad(0)), 0.1)

1682
	end

1683
	Magic(1, "Add", root.CFrame * CF(0, -1.9, -20), Vector3.new(1, 1, 1), 0.75, maincolor, "Sphere")

1684
	Magic(5, "Add", root.CFrame * CF(0, -1.9, -20), Vector3.new(0, 0, 0), 1, maincolor, "Sphere")

1685
	Magic(10, "Add", root.CFrame * CF(0, -1.9, -20), Vector3.new(0, 0, 0), 2, maincolor, "Sphere")

1686
	for i, v in pairs(FindNearestHead(root.CFrame.p, 25.5)) do

1687
		if v:FindFirstChild("Head") then

1688
			Eviscerate(v)

1689
		end

1690
	end

1691
	CameraEnshaking(4, 25)

1692
	for i = 0, 6, 0.1 do

1693
		swait()

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

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

1696
		RH.C0 = clerp(RH.C0, CF(1* Player_Size, -1.3 - 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(90)), 0.15)

1697
		LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -1.3 - 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(-90)), 0.15)

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

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

1700
		HW.C0 = clerp(HW.C0, CF(0, 2 + 0.2 * Cos(sine / 20), 0) * angles(Rad(0), Rad(0), Rad(0)), 0.1)

1701
	end

1702
	Blobby:Destroy()

1703
	attack = false

1704
	hum.WalkSpeed = 100

1705
end

1706
-------------------------------------------------------

1707
--End Attacks N Stuff--

1708
-------------------------------------------------------

1709
mouse.KeyDown:connect(function(key)

1710
	if attack == false then

1711
		if key == 't' then

1712
			

1713
1714
1715
1716
		elseif key == 'l' then

1717
1718
SONG = 1349585859

1719
Mode = 99900

1720
		tecks2.Text = "alone"

1721
		tecks2.TextColor3 = Color3.fromRGB(0, 255, 255)

1722
		tecks2.TextStrokeColor3 = Color3.fromRGB(255, 255, 255)

1723
		elseif key == 'y' then

1724
			

1725
1726
1727
1728
1729
		elseif key == 'k' then

1730
SONG = 1564523997

1731
Mode = 25

1732
		tecks2.Text = "triggered"

1733
		tecks2.TextColor3 = Color3.fromRGB(0, 255, 255)

1734
		tecks2.TextStrokeColor3 = Color3.fromRGB(255, 255, 255)

1735
		elseif key == 'z' then

1736
			

1737
1738
1739
1740
1741
		elseif key == 'j' then

1742
SONG = 1815812713

1743
Mode = 4

1744
		tecks2.Text = "muted"

1745
		tecks2.TextColor3 = Color3.fromRGB(0, 255, 255)

1746
		tecks2.TextStrokeColor3 = Color3.fromRGB(255, 255, 255)

1747
		elseif key == 'x' then

1748
			

1749
1750
1751
1752
		elseif key == 'h' then

1753
SONG = 1166995642

1754
Mode = 25

1755
        tecks2.Text = "punisher"

1756
        tecks2.TextColor3 = Color3.fromRGB(0, 0, 0)

1757
        tecks2.TextStrokeColor3 = Color3.fromRGB(255, 89, 89)

1758
		elseif key == 'c' then

1759
1760
1761
1762
1763
                elseif key == 'g' then

1764
SONG = 599679668

1765
Mode = 111111112

1766
		tecks2.Text = "sunny"

1767
		tecks2.TextColor3 = Color3.fromRGB(0, 255, 255)

1768
		tecks2.TextStrokeColor3 = Color3.fromRGB(255, 255, 255)

1769
		elseif key == 'f' then

1770
SONG = 826762530

1771
Mode = 1555

1772
		tecks2.Text = "hopeless"

1773
		tecks2.TextColor3 = Color3.fromRGB(0, 255, 255)

1774
		tecks2.TextStrokeColor3 = Color3.fromRGB(255, 255, 255)               

1775
                elseif key == 'r' then

1776
SONG = 657813878

1777
Mode = 98534

1778
		tecks2.Text = "psyche problems"

1779
		tecks2.TextColor3 = Color3.fromRGB(0, 255, 255)

1780
		tecks2.TextStrokeColor3 = Color3.fromRGB(255, 255, 255)

1781
1782
                elseif key == 'b' then

1783
Mode = 10

1784
SONG = 1138145518

1785
		tecks2.Text = "Dory-god"

1786
		tecks2.TextColor3 = Color3.fromRGB(0, 255, 255)

1787
		tecks2.TextStrokeColor3 = Color3.fromRGB(255, 255, 255)

1788
1789
                elseif key == 'o' then

1790
        Mode = 6

1791
        SONG = 634322702

1792
        tecks2.Text = "emo"

1793
        tecks2.TextColor3 = Color3.fromRGB(0, 255, 255)

1794
        tecks2.TextStrokeColor3 = Color3.fromRGB(255, 89, 89)

1795
		end

1796
	end

1797
end)

1798
1799
1800
1801
1802
1803
1804
1805
-------------------------------------------------------

1806
--Start Animations--

1807
-------------------------------------------------------

1808
while true do

1809
	swait()

1810
	sine = sine + change

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

1812
	local velderp = root.Velocity.y

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

1814
	if equipped == true or equipped == false then

1815
		if attack == false then

1816
			idle = idle + 1

1817
		else

1818
			idle = 0

1819
		end

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

1821
            Anim = "Jump"

1822
            if attack == false then

1823
                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.08)

1824
                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.08)

1825
                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.08)

1826
                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.08)

1827
                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.08)

1828
                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.08)

1829
            end

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

1831
            Anim = "Fall"

1832
            if attack == false then

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

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

1835
                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.08)

1836
                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.08)

1837
                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.08)

1838
                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.08)

1839
            end

1840
        elseif torvel < 1 and hitfloor ~= nil then

1841
            Anim = "Idle"

1842
            change = 1

1843
            if attack == false then

1844
                if Mode == 1 then --Normal

1845
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, 1.3 + 0.6 * Cos(sine / 20)) * angles(Rad(0), Rad(0), Rad(25)), 0.15)

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

1847
                RH.C0 = clerp(RH.C0, CF(1, -0.5 - 0.1 * Cos(sine / 20), -.4 + 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-4.5 + 3 * Sin(sine / 20)), Rad(0), Rad(10 + 3 * Sin(sine / 20))), 0.15)

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

1849
                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(65 - 2.5 * Sin(sine / 20))), 0.1)

1850
                LW.C0 = clerp(LW.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(-15 + 2.5 * Sin(sine / 20))), 0.1)

1851
                elseif Mode == 99900 then 

1852
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0 - 0.04 * Sin(sine / 24) * Player_Size, 0 + 0.04 * Sin(sine / 12) * Player_Size, 0 + 0.05 * Player_Size * Cos(sine / 12)) * angles(Rad(0 - 2.5 * Sin(sine / 12)), Rad(0 - 2.5 * Sin(sine / 24)), Rad(0)), 0.15)

1853
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(25 - 6.5 * Cos(sine / 12)), Rad(0), Rad(20 * Cos(sine / 12))), 0.3)

1854
                RH.C0 = clerp(RH.C0, CF(1 * Player_Size, -1 * Player_Size + 0.06 * Sin(sine / 24) - 0.05 * Player_Size * Cos(sine / 12), -0.01 * Player_Size) * angles(Rad(0 - 2.5 * Sin(sine / 12)), Rad(84), Rad(0)) * angles(Rad(-6 - 2.5 * Sin(sine / 24)), Rad(0), Rad(0)), 0.15)

1855
                LH.C0 = clerp(LH.C0, CF(-1 * Player_Size, -1 * Player_Size - 0.06 * Sin(sine / 24) - 0.05 * Player_Size * Cos(sine / 12), -0.01 * Player_Size) * angles(Rad(0 - 2.5 * Sin(sine / 12)), Rad(-84), Rad(0)) * angles(Rad(-6 + 2.5 * Sin(sine / 24)), Rad(0), Rad(0)), 0.15)

1856
                RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.35 + 0.15 * Cos(sine / 12)* Player_Size, 0* Player_Size) * angles(Rad(-6 + 4.5 * Sin(sine / 12)), Rad(25 + 2.5 * Sin(sine / 12)), Rad(25 + 4.5 * Sin(sine / 12))), 0.1)

1857
                LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.35 + 0.15 * Cos(sine / 12)* Player_Size, 0* Player_Size) * angles(Rad(7 + 4.5 * Sin(sine / 12)), Rad(0 + 2.5 * Sin(sine / 12)), Rad(-13 - 4.5 * Sin(sine / 12))), 0.1)

1858
                elseif Mode == 8888 then --idk

1859
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0 - 0.04 * Sin(sine / 24) * Player_Size, 0 + 0.04 * Sin(sine / 12) * Player_Size, 0 + 0.05 * Player_Size * Cos(sine / 12)) * angles(Rad(0 - 2.5 * Sin(sine / 12)), Rad(0 - 2.5 * Sin(sine / 24)), Rad(0)), 0.15)

1860
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(25 - 12.5 * Sin(sine / 12)), Rad(0), Rad(0)), 0.3)

1861
                RH.C0 = clerp(RH.C0, CF(1 * Player_Size, -1 * Player_Size - 0.06  - 0.05 * Player_Size * Cos(sine / 12), -0.01 * Player_Size) * angles(Rad(0 - 2.5 * Sin(sine / 12)), Rad(79), Rad(0)) * angles(Rad(-6 - 2.5 * Sin(sine / 24)), Rad(0), Rad(0)), 0.15)

1862
                LH.C0 = clerp(LH.C0, CF(-1 * Player_Size, -1 * Player_Size - 0.06  - 0.05 * Player_Size * Cos(sine / 12), -0.01 * Player_Size) * angles(Rad(0 - 2.5 * Sin(sine / 12)), Rad(-79), Rad(0)) * angles(Rad(-6 + 2.5 * Sin(sine / 24)), Rad(0), Rad(0)), 0.15)

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

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

1865
                elseif Mode == 98534 then

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

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

1868
                if Mrandom(1,15) == 1 then

1869
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * CF(0, 0, 0 + ((1) - 1)) * angles(Rad(Mrandom(-15,15)), Rad(Mrandom(-15,15)), Rad(Mrandom(-15,15))), 1)

1870
                end

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

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

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

1874
                LW.C0 = clerp(LW.C0, CF(-.8, 0.5 + 0.05 * Sin(sine / 20), -.4 + 0.025 * Cos(sine / 20)) * angles(Rad(0), Rad(20), Rad(-215)), 0.1)

1875
                elseif Mode == 56565 then --idk

1876
                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(20)), 0.15)

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

1878
                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(75), Rad(0)) * angles(Rad(-12.5), Rad(0), Rad(0)), 0.15)

1879
                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(-75), Rad(0)) * angles(Rad(-12.5), Rad(0), Rad(8)), 0.15)

1880
                RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.05 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(10), Rad(-.6), Rad(15 + 6.5 * Sin(sine / 20))), 0.1)

1881
                LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.05 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-10), Rad(-.6), Rad(-15 - 6.5 * Sin(sine / 20))), 0.1)

1882
                elseif Mode == pIXELATED then --PIXELATED

1883
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, -0.1 + 0.1* Player_Size * Cos(sine / 20)) * angles(Rad(20 + Mrandom(-4,4)), Rad(0), Rad(0)), 0.08)

1884
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(46 - 2.5 + Mrandom(-30,30)), Rad(-4.5 + Mrandom(-30,30)), Rad(-4.5 + Mrandom(-30,30))), 0.08)

1885
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0 + Mrandom(-6,6)), Rad(80), Rad(0)) * angles(Rad(-10.5 + Mrandom(-6,6)), Rad(0 + Mrandom(-6,6)), Rad(20 + Mrandom(-6,6))), 0.08)

1886
                LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0 + Mrandom(-6,6)), Rad(-80 + Mrandom(-6,6)), Rad(0 + Mrandom(-6,6))) * angles(Rad(-10.5 + Mrandom(-6,6)), Rad(0 + Mrandom(-6,6)), Rad(-20 + Mrandom(-6,6))), 0.08)

1887
                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 + Mrandom(-6,6)), Rad(0 + Mrandom(-6,6)), Rad(5 + Mrandom(-6,6))), 0.08)

1888
                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 + Mrandom(-6,6)), Rad(0 + Mrandom(-6,6)), Rad(-5 + Mrandom(-6,6))), 0.08)

1889
                elseif Mode == 50 then --ASCENDED

1890
                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(0)), 0.08)

1891
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(15 - 4.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.08)

1892
                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(80), Rad(0)) * angles(Rad(-6.5), Rad(0), Rad(0)), 0.08)

1893
                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(-80), Rad(0)) * angles(Rad(-6.5), Rad(0), Rad(0)), 0.08)

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

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

1896
            elseif Mode == 7777 then --NOTHING SPECIAL

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

1898
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(20), Rad(0), Rad(0)), 0.3)

1899
                if Mrandom(1,15) == 1 then

1900
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * CF(0, 0, 0 + ((1) - 1)) * angles(Rad(Mrandom(-15,15)), Rad(Mrandom(-15,15)), Rad(Mrandom(-15,15))), 1)

1901
                end

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

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

1904
                RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(15 - 4 * Cos(sine / 20)), Rad(0), Rad(5)), 0.1)

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

1906
            elseif Mode == 6666 then --MEMER

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

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

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

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

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

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

1913
            elseif Mode == 2 then --Machinery

1914
                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(20)), 0.08)

1915
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(46 - 2.5 * Sin(sine / 30)), Rad(-4.5 * Sin(sine / .5)), Rad(-20 - 4.5 * Sin(sine / .5))), 0.08)

1916
                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(80), Rad(0)) * angles(Rad(-10.5), Rad(0), Rad(0)), 0.08)

1917
                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(-80), Rad(0)) * angles(Rad(-10.5), Rad(0), Rad(0)), 0.08)

1918
                RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(155), Rad(0), Rad(-45)), 0.08)

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

1920
            elseif Mode == 3 then --ICE

1921
rootj.C0=clerp(rootj.C0,RootCF*CF(0,0,-0.1+0.1*math.cos(sine/20))*angles(math.rad(-20),math.rad(0),math.rad(0)),0.15)

1922
tors.Neck.C0=clerp(tors.Neck.C0,necko*angles(math.rad(-15*math.sin(sine/25)/2),math.rad(0),math.rad(10*math.sin(sine/25))),.3)

1923
RH.C0=clerp(RH.C0,CF(1,-0.9-0.1*math.cos(sine/20),0.025*math.cos(sine/20))*RHCF*angles(math.rad(-10),math.rad(-0),math.rad(-25)),0.15)

1924
LH.C0=clerp(LH.C0,CF(-1,-0.9-0.1*math.cos(sine/20),0.025*math.cos(sine/20))*LHCF*angles(math.rad(-3),math.rad(-4*math.sin(sine/25)),math.rad(15)),0.15)

1925
RW.C0 = clerp(RW.C0, CFrame.new(1.5, 0.5+0.04*math.sin(sine/25), 0) * angles(math.rad(-35 ), math.rad(-7*math.sin(sine/25)), math.rad(5)), 0.1)

1926
LW.C0 = clerp(LW.C0, CFrame.new(-1.5, 0.5+0.04*math.sin(sine/25),0) * angles(math.rad(-35 ), math.rad(7*math.sin(sine/25)), math.rad(-5)), 0.1)

1927
            elseif Mode == 4 then --Infused

1928
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, 1.2 + 0.3 * Cos(sine / 20)) * angles(Rad(5), Rad(0), Rad(10)), 0.15)

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

1930
                RH.C0 = clerp(RH.C0, CF(1, -0.4 - 0.1 * Cos(sine / 20), -.4 + 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-2.5 + 3 * Sin(sine / 20)), Rad(0), Rad(-20 + 2.5 * Sin(sine / 20))), 0.15)

1931
                LH.C0 = clerp(LH.C0, CF(-1, -0.9 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * LHCF * angles(Rad(-2.5 + 3 * Sin(sine / 20)), Rad(0), Rad(0 + 2.5 * Sin(sine / 20))), 0.15)

1932
                RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(-3 * Sin(sine / 20)), Rad(-10 * Sin(sine / 20)), Rad(13 - 2.5 * Sin(sine / 20))), 0.1)

1933
                LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(4 * Sin(sine / 20)), Rad(10 * Sin(sine / 20)), Rad(-13 + 2.5 * Sin(sine / 20))), 0.1)

1934
            elseif Mode == 5 then --Cybernetic

1935
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, 1 + 0.5 * Player_Size * Cos(sine / 20)) * angles(Rad(0), Rad(0), Rad(0)), 0.08)

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

1937
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.3 - 0.1 * Cos(sine / 20)* Player_Size, -.4* Player_Size) * angles(Rad(0), Rad(80), Rad(0)) * angles(Rad(-10.5 + 3.5 * Sin(sine / 20)), Rad(0), Rad(-20)), 0.08)

1938
                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(-80), Rad(0)) * angles(Rad(-10.5 + 3.5 * Sin(sine / 20)), Rad(0), Rad(20)), 0.08)

1939
                RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(0), Rad(25 + 10.5 * Sin(sine / 20))), 0.08)

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

1941
            elseif Mode == 25 then --Spiritual

1942
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, 1 + 0.5 * Player_Size * Cos(sine / 20)) * angles(Rad(0), Rad(0), Rad(0)), 0.08)

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

1944
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.3 - 0.1 * Cos(sine / 20)* Player_Size, -.4* Player_Size) * angles(Rad(0), Rad(80), Rad(0)) * angles(Rad(-10.5 + 3.5 * Sin(sine / 20)), Rad(0), Rad(-20)), 0.08)

1945
                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(-80), Rad(0)) * angles(Rad(-10.5 + 3.5 * Sin(sine / 20)), Rad(0), Rad(20)), 0.08)

1946
                RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(0), Rad(25 + 10.5 * Sin(sine / 20))), 0.08)

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

1948
            elseif Mode == 6 then --Controlled Beyond Recognition

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

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

1951
                if Mrandom(1,15) == 1 then

1952
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * CF(0, 0, 0 + ((1) - 1)) * angles(Rad(Mrandom(-15,15)), Rad(Mrandom(-15,15)), Rad(Mrandom(-15,15))), 1)

1953
                end

1954
                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(10)), 0.15)

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

1956
                RW.C0 = clerp(RW.C0, CF(.8, 0.5 + 0.05 * Sin(sine / 20), -.4 + 0.025 * Cos(sine / 20)) * angles(Rad(0), Rad(-20), Rad(215)), 0.1)

1957
                LW.C0 = clerp(LW.C0, CF(-.8, 0.5 + 0.05 * Sin(sine / 20), -.4 + 0.025 * Cos(sine / 20)) * angles(Rad(0), Rad(20), Rad(-215)), 0.1)

1958
            elseif Mode == 1800 then --demon

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

1960
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(20 - 2.5 * Sin(sine / 20)), Rad(Mrandom(-45, 45)), Rad(Mrandom(-45, 45))), 0.1)

1961
                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(85), Rad(0)) * angles(Rad(-5), Rad(Mrandom(-15, 15)), Rad(20)), 0.1)

1962
                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(-85), Rad(0)) * angles(Rad(-5), Rad(Mrandom(-15, 15)), Rad(-20)), 0.1)

1963
                RW.C0 = clerp(RW.C0, CF(1* Player_Size, 0.8* Player_Size + 0.01 * Sin(sine / 20)* Player_Size, -0.6* Player_Size) * angles(Rad(165), Rad(Mrandom(-15, 15)), Rad(-50)), 0.1)

1964
                LW.C0 = clerp(LW.C0, CF(-1* Player_Size, 0.8* Player_Size + 0.01 * Sin(sine / 20)* Player_Size, -0.6* Player_Size) * angles(Rad(165), Rad(Mrandom(-15, 15)), Rad(50)), 0.1)

1965
            elseif Mode == 7 or Mode == 9 then --Sucho Wowo --Mr.Balancia  ----------hdfsfhg

1966
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0 - 0.04 * Sin(sine / 24) * Player_Size, 0 + 0.04 * Sin(sine / 12) * Player_Size, 0 + 0.05 * Player_Size * Cos(sine / 12)) * angles(Rad(0 - 2.5 * Sin(sine / 12)), Rad(0 - 2.5 * Sin(sine / 24)), Rad(0)), 0.08)

1967
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(25 - 2.5 * Sin(sine / 12)), Rad(0), Rad(0)), 0.08)

1968
                RH.C0 = clerp(RH.C0, CF(1 * Player_Size, -1 * Player_Size - 0.06  - 0.05 * Player_Size * Cos(sine / 12), -0.01 * Player_Size) * angles(Rad(0 - 2.5 * Sin(sine / 12)), Rad(79), Rad(0)) * angles(Rad(-6 - 2.5 * Sin(sine / 24)), Rad(0), Rad(0)), 0.08)

1969
                LH.C0 = clerp(LH.C0, CF(-1 * Player_Size, -1 * Player_Size - 0.06  - 0.05 * Player_Size * Cos(sine / 12), -0.01 * Player_Size) * angles(Rad(0 - 2.5 * Sin(sine / 12)), Rad(-79), Rad(0)) * angles(Rad(-6 + 2.5 * Sin(sine / 24)), Rad(0), Rad(0)), 0.08)

1970
                RW.C0 = clerp(RW.C0, CF(1 * Player_Size, 0.5 + 0.02 * Sin(sine / 12)* Player_Size, .6* Player_Size) * angles(Rad(-20), Rad(-.6), Rad(-43)), 0.08)

1971
                LW.C0 = clerp(LW.C0, CF(-1 * Player_Size, 0.5 + 0.02 * Sin(sine / 12)* Player_Size, .6* Player_Size) * angles(Rad(-20), Rad(-.6), Rad(43)), 0.08)

1972
            elseif Mode == 1555 then --anime

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

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

1975
                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(-10)), 0.15)

1976
                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(6)), 0.15)

1977
                RW.C0 = clerp(RW.C0, CF(.8, 0.5 + 0.05 * Sin(sine / 20), -.6 + 0.025 * Cos(sine / 20)) * angles(Rad(21), Rad(11), Rad(-90 - 2.5 * Sin(sine / 20))), 0.1)

1978
                LW.C0 = clerp(LW.C0, CF(-.8, 0.3 + 0.05 * Sin(sine / 20), -.6 + 0.025 * Cos(sine / 20)) * angles(Rad(8), Rad(5), Rad(90 + 2.5 * Sin(sine / 20))), 0.1)

1979
            elseif Mode == 111111111 then

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

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

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

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

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

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

1986
            elseif Mode == 100 then --Overclocked

1987
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, 1.3 + 0.6 * Cos(sine / 20)) * angles(Rad(0), Rad(0), Rad(25)), 0.15)

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

1989
                RH.C0 = clerp(RH.C0, CF(1, -0.5 - 0.1 * Cos(sine / 20), -.4 + 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-4.5 + 3 * Sin(sine / 20)), Rad(0), Rad(10 + 3 * Sin(sine / 20))), 0.15)

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

1991
                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(65 - 2.5 * Sin(sine / 20))), 0.1)

1992
                LW.C0 = clerp(LW.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(-15 + 2.5 * Sin(sine / 20))), 0.1)

1993
            elseif Mode == 8 then --Lunarist

1994
                MagicCharge(7, 0, "Add", ra.CFrame * CF(0, -1.3, 0) * CFrame.Angles(math.rad(math.random(-360, 360)), math.rad(math.random(-360, 360)), math.rad(math.random(-360, 360))), 0.5, 0.5, 1.5 * math.random(-1.8, 2), -0.005, maincolor, 0, "Brick")

1995
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, 0.8 + 0.2* Player_Size * Cos(sine / 20)) * angles(Rad(0), Rad(0), Rad(0)), 0.08)

1996
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(15 - 4.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.08)

1997
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.3 - 0.1 * Cos(sine / 20)* Player_Size, -0.5* Player_Size) * angles(Rad(0), Rad(75), Rad(0)) * angles(Rad(-6.5), Rad(0), Rad(0)), 0.08)

1998
                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(-75), Rad(0)) * angles(Rad(-6.5), Rad(0), Rad(0)), 0.08)

1999
                RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(-.6), Rad(135)), 0.08)

2000
                LW.C0 = clerp(LW.C0, CF(-1 * Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, .6* Player_Size) * angles(Rad(-20), Rad(-.6), Rad(43)), 0.08)

2001
            elseif Mode == 111111112 then

2002
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, 2 + 0.25* Player_Size * Cos(sine / 12)) * angles(Rad(25), Rad(0), Rad(0)), 0.1)

2003
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(15 - 6.5 * Sin(sine / 12)), Rad(0), Rad(0)), 0.05)

2004
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -1 - 0.15 * Cos(sine / 20)* Player_Size, -0.1* Player_Size) * angles(Rad(0), Rad(76), Rad(0)) * angles(Rad(-8.5 - 6.5 * Sin(sine / 12)), Rad(0), Rad(15)), 0.1)

2005
                LH.C0 = clerp(LH.C0, CF(-1.1* Player_Size, -0.6 - 0.15 * Cos(sine / 20)* Player_Size, -0.3* Player_Size) * angles(Rad(0), Rad(-76), Rad(0)) * angles(Rad(-8.5 - 6.5 * Sin(sine / 12)), Rad(15), Rad(25)), 0.1)

2006
                RW.C0 = clerp(RW.C0, CF(1.4* Player_Size, 0.4 + 0.08 * Sin(sine / 12)* Player_Size, 0* Player_Size) * angles(Rad(25 - 6.5 * Cos(sine / 12)), Rad(-.6), Rad(13 + 6.5 * Sin(sine / 12))), 0.1)

2007
                LW.C0 = clerp(LW.C0, CF(-1.4* Player_Size, 0.4 + 0.08 * Sin(sine / 12)* Player_Size, 0* Player_Size) * angles(Rad(25 - 6.5 * Cos(sine / 12)), Rad(-.6), Rad(-13 - 6.5 * Sin(sine / 12))), 0.1)

2008
            elseif Mode == 10 then --INSANITY

2009
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.2 + 0.1 * Cos(sine / 7)) * angles(Rad(10), Rad(0), Rad(0)), 0.15)

2010
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(45), Rad(0), Rad(-20)), 0.3)

2011
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.1 + 0.1 * Cos(sine / 7)) * angles(Rad(10 + Mrandom(-6,6)), Rad(0), Rad(Mrandom(-6,6))), 0.15)

2012
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * CF(0, 0, 0 + ((1) - 1)) * angles(Rad(45 + Mrandom(-4,4)), Rad(Mrandom(-4,4)), Rad(-20 + Mrandom(-4,4))), 1)

2013
                RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 7), 0.025 * Cos(sine / 7)) * angles(Rad(180 + Mrandom(-35,35)), Rad(35 + Mrandom(-35,35)), Rad(-50 - 2.5 * Sin(sine / 20) + Mrandom(-35,35))), 0.1)

2014
                LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 7), 0.025 * Cos(sine / 7)) * angles(Rad(15 + Mrandom(-35,35)), Rad(Mrandom(-35,35)), Rad(-15 + 2.5 * Sin(sine / 20) + Mrandom(-35,35))), 0.1)

2015
                RH.C0 = clerp(RH.C0, CF(1, -0.9 - 0.1 * Cos(sine / 7), -.2 +  0.025 * Cos(sine / 7)) * RHCF * angles(Rad(-5 + Mrandom(-6,6)), Rad(0), Rad(10 + Mrandom(-6,6))), 0.15)

2016
                LH.C0 = clerp(LH.C0, CF(-1, -0.9 - 0.1 * Cos(sine / 7), 0.025 * Cos(sine / 7)) * LHCF * angles(Rad(-5 + Mrandom(-6,6)), Rad(0), Rad(-10 + Mrandom(-6,6))), 0.15)

2017
            end

2018
            end

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

2020
            Anim = "Walk"

2021
            change = 1.1

2022
            if attack == false then

2023
                if Mode == 6 then

2024
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.175 + 0.025 * Cos(sine / 3.5) + -Sin(sine / 3.5) / 7) * angles(Rad(4-2.5 * Cos(sine / 3.5)), Rad(0) - root.RotVelocity.Y / 75, Rad(5 * Cos(sine / 7))), 0.15)

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

2026
                if Mrandom(1,15) == 1 then

2027
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * CF(0, 0, 0 + ((1) - 1)) * angles(Rad(Mrandom(-15,15)), Rad(Mrandom(-15,15)), Rad(Mrandom(-15,15))), 1)

2028
                end

2029
                RH.C0 = clerp(RH.C0, CF(1, -0.925 - 0.5 * Cos(sine / 7) / 2, 0.5 * Cos(sine / 7) / 2) * angles(Rad(-15 - 5 * 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)

2030
                LH.C0 = clerp(LH.C0, CF(-1, -0.925 + 0.5 * Cos(sine / 7) / 2, -0.5 * Cos(sine / 7) / 2) * angles(Rad(-15 + 5 * 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)

2031
                RW.C0 = clerp(RW.C0, CF(.8, 0.5 + 0.05 * Sin(sine / 20), -.4 + 0.025 * Cos(sine / 20)) * angles(Rad(0), Rad(-20), Rad(215)), 0.1)

2032
                LW.C0 = clerp(LW.C0, CF(-.8, 0.5 + 0.05 * Sin(sine / 20), -.4 + 0.025 * Cos(sine / 20)) * angles(Rad(0), Rad(20), Rad(-215)), 0.1)

2033
                elseif Mode == 3 then

2034
				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(8 * Cos(sine / 7))), 0.15)

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

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

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

2038
				RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 7), 0) * angles(Rad(37)  * Cos(sine / 7) , Rad(0), Rad(-.6) - ra.RotVelocity.Y / 75), 0.1)

2039
				LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 7), 0) * angles(Rad(-37)  * Cos(sine / 7) , Rad(0) ,	Rad(.6) + la.RotVelocity.Y / 75), 0.1)

2040
                elseif Mode == 98534 then

2041
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.175 + 0.025 * Cos(sine / 3.5) + -Sin(sine / 3.5) / 7) * angles(Rad(9-2.5 * Cos(sine / 3.5)), Rad(0) - root.RotVelocity.Y / 75, Rad(10 * Cos(sine / 7))), 0.15)

2042
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(0), Rad(30 * Cos(sine / 20)), Rad(0) - hed.RotVelocity.Y / 15), 0.3)

2043
                RH.C0 = clerp(RH.C0, CF(1, -0.925 - 0.5 * Cos(sine / 7) / 2, 0.5 * Cos(sine / 7) / 2) * angles(Rad(-15 - 35 * 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)

2044
                LH.C0 = clerp(LH.C0, CF(-1, -0.925 + 0.5 * Cos(sine / 7) / 2, -0.5 * Cos(sine / 7) / 2) * angles(Rad(-15 + 35 * 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)

2045
                RW.C0 = clerp(RW.C0, CF(1.4, 0.5 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(90), Rad(0), Rad(-15) - ra.RotVelocity.Y / 75), 0.1)

2046
                LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(-70)  * Cos(sine / 7) , Rad(0) ,    Rad(-5) + la.RotVelocity.Y / 75), 0.1)

2047
                elseif Mode == 111111112 then

2048
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, 2 + 0.25* Player_Size * Cos(sine / 12)) * angles(Rad(25), Rad(0), Rad(0)), 0.1)

2049
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(-15 - 6.5 * Sin(sine / 12)), Rad(20), Rad(0)), 0.1)

2050
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -1 - 0.15 * Cos(sine / 20)* Player_Size, -0.1* Player_Size) * angles(Rad(0), Rad(76), Rad(0)) * angles(Rad(-18.5 - 6.5 * Sin(sine / 12)), Rad(0), Rad(-35)), 0.1)

2051
                LH.C0 = clerp(LH.C0, CF(-1.1* Player_Size, -0.6 - 0.15 * Cos(sine / 20)* Player_Size, -0.2* Player_Size) * angles(Rad(0), Rad(-76), Rad(0)) * angles(Rad(-18.5 - 6.5 * Sin(sine / 12)), Rad(15), Rad(35)), 0.1)

2052
                RW.C0 = clerp(RW.C0, CF(1.4* Player_Size, 0.4 + 0.08 * Sin(sine / 12)* Player_Size, 0* Player_Size) * angles(Rad(-45 - 6.5 * Cos(sine / 12)), Rad(-.6), Rad(25 + 6.5 * Sin(sine / 12))), 0.1)

2053
                LW.C0 = clerp(LW.C0, CF(-1.4* Player_Size, 0.4 + 0.08 * Sin(sine / 12)* Player_Size, 0* Player_Size) * angles(Rad(-45 - 6.5 * Cos(sine / 12)), Rad(-.6), Rad(-25 - 6.5 * Sin(sine / 12))), 0.1)

2054
                elseif Mode == 111111111 then

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

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

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

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

2059
                RW.C0 = clerp(RW.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)

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

2061
                elseif Mode == 99900 then

2062
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, -0.175 + 0.13 * Cos(sine / 3.5) + -Sin(sine / 3.5) / 7* Player_Size) * angles(Rad(3 - 2.5 * Cos(sine / 3.5)), Rad(0) - root.RotVelocity.Y / 75, Rad(10 * Cos(sine / 7))), 0.15)

2063
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(0), Rad(0), Rad(0) - hed.RotVelocity.Y / 15), 0.3)

2064
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.8 - 0.5 * Cos(sine / 7) / 2* Player_Size, 0.6 * Cos(sine / 7) / 2* Player_Size)  * angles(Rad(-10 - 25 * Cos(sine / 7)) - rl.RotVelocity.Y / 75 + -Sin(sine / 7) / 2.5, Rad(90 - 15 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 + 2 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2065
                LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.8 + 0.5 * Cos(sine / 7) / 2* Player_Size, -0.6 * Cos(sine / 7) / 2* Player_Size) * angles(Rad(-10 + 25 * Cos(sine / 7)) + ll.RotVelocity.Y / 75 + Sin(sine / 7) / 2.5, Rad(-90 - 15 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 - 2 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2066
                RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.05 * Sin(sine / 7)* Player_Size, 0* Player_Size) * angles(Rad(57)  * Cos(sine / 7) , Rad(10 * Cos(sine / 7)), Rad(10) - ra.RotVelocity.Y / 75), 0.1)

2067
                LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.05 * Sin(sine / 7)* Player_Size, 0* Player_Size) * angles(Rad(-57)  * Cos(sine / 7) , Rad(10 * Cos(sine / 7)) ,  Rad(-10) + la.RotVelocity.Y / 75), 0.1)

2068
                elseif Mode == 1 then --Normal

2069
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, 1.3 + 0.6 * Cos(sine / 20)) * angles(Rad(30), Rad(0), Rad(0)), 0.15)

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

2071
                RH.C0 = clerp(RH.C0, CF(1, -0.5 - 0.1 * Cos(sine / 20), -.4 + 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-4.5 + 3 * Sin(sine / 20)), Rad(0), Rad(-10 + 3 * Sin(sine / 20))), 0.15)

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

2073
                RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 20), 0.025 * Cos(sine / 20)) * angles(Rad(-17), Rad(-10 * Cos(sine / 20)), Rad(15 - 2.5 * Sin(sine / 20))), 0.1)

2074
                LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 20), 0.025 * Cos(sine / 20)) * angles(Rad(-17), Rad(10 * Cos(sine / 20)), Rad(-15 + 2.5 * Sin(sine / 20))), 0.1)

2075
                elseif Mode == 7777 then --NORTHING SPECIAL

2076
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.175 + 0.025 * Cos(sine / 3.5) + -Sin(sine / 3.5) / 7) * angles(Rad(7-2.5 * Cos(sine / 3.5)), Rad(0), Rad(10 * Cos(sine / 7))), 0.15)

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

2078
                RH.C0 = clerp(RH.C0, CF(1, -0.925 - 0.1 * Cos(sine / 3.5), 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-1.5), Rad(0), Rad(70) * Cos(sine / 7) ), 0.15)

2079
                LH.C0 = clerp(LH.C0, CF(-1, -0.925 + 0.1 * Cos(sine / 3.5), 0.025 * Cos(sine / 20)) * LHCF * angles(Rad(-1.5), Rad(0), Rad(70) * Cos(sine / 7) ), 0.15)

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

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

2082
                elseif Mode == 4 then --Infused

2083
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, 1.2 + 0.3 * Cos(sine / 20)) * angles(Rad(25), Rad(0), Rad(0)), 0.15)

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

2085
                RH.C0 = clerp(RH.C0, CF(1, -0.4 - 0.1 * Cos(sine / 20), -.4 + 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-2.5 + 3 * Sin(sine / 20)), Rad(0), Rad(-20 + 2.5 * Sin(sine / 20))), 0.15)

2086
                LH.C0 = clerp(LH.C0, CF(-1, -0.9 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * LHCF * angles(Rad(-2.5 + 3 * Sin(sine / 20)), Rad(0), Rad(20 + 2.5 * Sin(sine / 20))), 0.15)

2087
                RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(-25 - 3 * Sin(sine / 20)), Rad(-10 * Sin(sine / 20)), Rad(14 - 2.5 * Sin(sine / 20))), 0.1)

2088
                LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(-25 + 4 * Sin(sine / 20)), Rad(10 * Sin(sine / 20)), Rad(-14 + 2.5 * Sin(sine / 20))), 0.1)

2089
                elseif Mode == 56565 then --idk

2090
                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(3 - 2.5 * Cos(sine / 3.5)), Rad(0) - root.RotVelocity.Y / 75, Rad(8 * Cos(sine / 7))), 0.15)

2091
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(6 - 2.5 * Sin(sine / 7)), Rad(0), Rad(0) - hed.RotVelocity.Y / 15), 0.3)

2092
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.8 - 0.5 * Cos(sine / 7) / 2* Player_Size, 0.6 * Cos(sine / 7) / 2* Player_Size)  * angles(Rad(-10 - 25 * Cos(sine / 7)) - rl.RotVelocity.Y / 75 + -Sin(sine / 7) / 2.5, Rad(90 - 10 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 + 2 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2093
                LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.8 + 0.5 * Cos(sine / 7) / 2* Player_Size, -0.6 * Cos(sine / 7) / 2* Player_Size) * angles(Rad(-10 + 25 * Cos(sine / 7)) + ll.RotVelocity.Y / 75 + Sin(sine / 7) / 2.5, Rad(-90 - 10 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 - 2 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2094
                RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.05 * Sin(sine / 7)* Player_Size, 0* Player_Size) * angles(Rad(37)  * Cos(sine / 7) , Rad(8 * Cos(sine / 7)), Rad(6) - ra.RotVelocity.Y / 75), 0.1)

2095
                LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.05 * Sin(sine / 7)* Player_Size, 0* Player_Size) * angles(Rad(-37)  * Cos(sine / 7) , Rad(8 * Cos(sine / 7)) ,   Rad(-6) + la.RotVelocity.Y / 75), 0.1)

2096
                elseif Mode == 8888 then --ik

2097
                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(3 - 2.5 * Cos(sine / 3.5)), Rad(0) - root.RotVelocity.Y / 75, Rad(8 * Cos(sine / 7))), 0.15)

2098
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(6 - 2.5 * Sin(sine / 7)), Rad(0), Rad(0) - hed.RotVelocity.Y / 15), 0.3)

2099
                RH.C0 = clerp(RH.C0, CF(1 * Player_Size, -0.8 * Player_Size - 0.5 * Player_Size * Cos(sine / 7) / 2 * Player_Size, 0.6 * Player_Size * Cos(sine / 7) / 2 * Player_Size)  * angles(Rad(-15 - 35 * 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)

2100
                LH.C0 = clerp(LH.C0, CF(-1 * Player_Size, -0.8 * Player_Size + 0.5 * Player_Size * Cos(sine / 7) / 2 * Player_Size, -0.6 * Player_Size * Cos(sine / 7) / 2 * Player_Size) * angles(Rad(-15 + 35 * 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)

2101
                RW.C0 = clerp(RW.C0, CF(1.5 * Player_Size, 0.5 + 0.02 * Sin(sine / 12)* Player_Size, 0* Player_Size) * angles(Rad(65) * Cos(sine / 7), Rad(-.6), Rad(15 + 4.5 * Sin(sine / 12))), 0.1)

2102
                LW.C0 = clerp(LW.C0, CF(-1.5 * Player_Size, 0.5 + 0.02 * Sin(sine / 12)* Player_Size, 0* Player_Size) * angles(Rad(-65) * Cos(sine / 7), Rad(-.6), Rad(-15 - 4.5 * Sin(sine / 12))), 0.1)

2103
            elseif Mode == 1555 then --anime

2104
                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(3 - 2.5 * Cos(sine / 3.5)), Rad(0) - root.RotVelocity.Y / 75, Rad(8 * Cos(sine / 7))), 0.15)

2105
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(6 - 2.5 * Sin(sine / 7)), Rad(0), Rad(0) - hed.RotVelocity.Y / 15), 0.3)

2106
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.8 - 0.5 * Cos(sine / 7) / 2* Player_Size, 0.6 * Cos(sine / 7) / 2* Player_Size)  * angles(Rad(-10 - 25 * Cos(sine / 7)) - rl.RotVelocity.Y / 75 + -Sin(sine / 7) / 2.5, Rad(90 - 10 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 + 2 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2107
                LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.8 + 0.5 * Cos(sine / 7) / 2* Player_Size, -0.6 * Cos(sine / 7) / 2* Player_Size) * angles(Rad(-10 + 25 * Cos(sine / 7)) + ll.RotVelocity.Y / 75 + Sin(sine / 7) / 2.5, Rad(-90 - 10 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 - 2 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2108
                RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.05 * Sin(sine / 7)* Player_Size, 0* Player_Size) * angles(Rad(37)  * Cos(sine / 7) , Rad(8 * Cos(sine / 7)), Rad(6) - ra.RotVelocity.Y / 75), 0.1)

2109
                LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.05 * Sin(sine / 7)* Player_Size, 0* Player_Size) * angles(Rad(-37)  * Cos(sine / 7) , Rad(8 * Cos(sine / 7)) ,   Rad(-6) + la.RotVelocity.Y / 75), 0.1)

2110
            elseif Mode == 6666 then

2111
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.175 + 0.025 * Cos(sine / 3.5) + -Sin(sine / 3.5) / 7) * angles(Rad(9-2.5 * Cos(sine / 3.5)), Rad(0), Rad(10 * Cos(sine / 7))), 0.15)

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

2113
                RH.C0 = clerp(RH.C0, CFrame.new(1, -0.925 - 0.5 * math.cos(sine / 7) / 2, 0.5 * math.cos(sine / 7) / 2) * angles(math.rad(-15 - 35 * math.cos(sine / 7)) + -math.sin(sine / 7) / 2.5, math.rad(90 - 2 * math.cos(sine / 7)), math.rad(0)) * angles(math.rad(0 + 2.5 * math.cos(sine / 7)), math.rad(0), math.rad(0)), 0.3)

2114
                LH.C0 = clerp(LH.C0, CFrame.new(-1, -0.925 + 0.5 * math.cos(sine / 7) / 2, -0.5 * math.cos(sine / 7) / 2) * angles(math.rad(-15 + 35 * math.cos(sine / 7)) + math.sin(sine / 7) / 2.5, math.rad(-90 - 2 * math.cos(sine / 7)), math.rad(0)) * angles(math.rad(0 - 2.5 * math.cos(sine / 7)), math.rad(0), math.rad(0)), 0.3)

2115
                RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(70) * Cos(sine / 7) , Rad(0), Rad(5)), 0.1)

2116
                LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(-70) * Cos(sine / 7) , Rad(0),  Rad(-5)), 0.1)

2117
            elseif Mode == 1800 then

2118
                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(20 - 2.5 * Cos(sine / 3.5)), Rad(0) - root.RotVelocity.Y / 75, Rad(8 * Cos(sine / 7))), 0.15)

2119
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(46 - 2.5 * Sin(sine / 7)), Rad(0), Rad(0) - hed.RotVelocity.Y / 15), 0.3)

2120
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.8 - 0.5 * Cos(sine / 7) / 2* Player_Size, 0.6 * Cos(sine / 7) / 2* Player_Size)  * angles(Rad(-5 - 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(20)), 0.3)

2121
                    LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.8 + 0.5 * Cos(sine / 7) / 2* Player_Size, -0.6 * Cos(sine / 7) / 2* Player_Size) * angles(Rad(-5 + 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(-20)), 0.3)

2122
                RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.05 * Sin(sine / 7)* Player_Size, 0* Player_Size) * angles(Rad(25 + 15 * Cos(sine / 7)), Rad(0), Rad(5) - ra.RotVelocity.Y / 75), 0.1)

2123
                LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.05 * Sin(sine / 7)* Player_Size, 0* Player_Size) * angles(Rad(25 - 15 * Cos(sine / 7)), Rad(0), Rad(-5) + la.RotVelocity.Y / 75), 0.1)

2124
            elseif Mode == 5 then

2125
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, 1 + 0.5 * Player_Size * Cos(sine / 20)) * angles(Rad(20), Rad(0), Rad(0)), 0.15)

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

2127
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.3 - 0.1 * Cos(sine / 20)* Player_Size, -.4* Player_Size) * angles(Rad(0), Rad(80), Rad(0)) * angles(Rad(-10.5 + 3.5 * Sin(sine / 20)), Rad(0), Rad(-20)), 0.15)

2128
                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(-80), Rad(0)) * angles(Rad(-10.5 + 3.5 * Sin(sine / 20)), Rad(0), Rad(20)), 0.15)

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

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

2131
            elseif Mode == 25 then

2132
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, 1 + 0.5 * Player_Size * Cos(sine / 20)) * angles(Rad(20), Rad(0), Rad(0)), 0.15)

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

2134
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.3 - 0.1 * Cos(sine / 20)* Player_Size, -.4* Player_Size) * angles(Rad(0), Rad(80), Rad(0)) * angles(Rad(-10.5 + 3.5 * Sin(sine / 20)), Rad(0), Rad(-20)), 0.15)

2135
                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(-80), Rad(0)) * angles(Rad(-10.5 + 3.5 * Sin(sine / 20)), Rad(0), Rad(20)), 0.15)

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

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

2138
            elseif Mode == 100 then

2139
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, 1.3 + 0.6 * Cos(sine / 20)) * angles(Rad(30), Rad(0), Rad(0)), 0.15)

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

2141
                RH.C0 = clerp(RH.C0, CF(1, -0.5 - 0.1 * Cos(sine / 20), -.4 + 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-4.5 + 3 * Sin(sine / 20)), Rad(0), Rad(-10 + 3 * Sin(sine / 20))), 0.15)

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

2143
                RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 20), 0.025 * Cos(sine / 20)) * angles(Rad(-17), Rad(-10 * Cos(sine / 20)), Rad(15 - 2.5 * Sin(sine / 20))), 0.1)

2144
                LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 20), 0.025 * Cos(sine / 20)) * angles(Rad(-17), Rad(10 * Cos(sine / 20)), Rad(-15 + 2.5 * Sin(sine / 20))), 0.1)

2145
            elseif Mode == 10 then

2146
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * CF(0, 0, 0 + ((1) - 1)) * angles(Rad(55 + Mrandom(-20,20)), Rad(Mrandom(-20,20)), Rad(-0 + Mrandom(-20,20))), 1)

2147
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, 1.3 + 0.6 * Cos(sine / 20)) * angles(Rad(30), Rad(0), Rad(0)), 0.15)

2148
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(55), Rad(0), Rad(-0)), 0.3)

2149
                RH.C0 = clerp(RH.C0, CF(1, -0.5 - 0.1 * Cos(sine / 20), -.4 + 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-4.5 + Mrandom(-23,23)), Rad(0 + Mrandom(-23,23)), Rad(35 + Mrandom(-23,23))), 0.15)

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

2151
                RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 20), 0.025 * Cos(sine / 20)) * angles(Rad(35 + Mrandom(-23,23)), Rad(-10 + Mrandom(-23,23)), Rad(15 + Mrandom(-23,23))), 0.1)

2152
                LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 20), 0.025 * Cos(sine / 20)) * angles(Rad(35 + Mrandom(-23,23)), Rad(10 + Mrandom(-23,23)), Rad(-15 + Mrandom(-23,23))), 0.1)

2153
            elseif Mode == 8 then

2154
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, 0.8 + 0.2* Player_Size * Cos(sine / 20)) * angles(Rad(20), Rad(0), Rad(0)), 0.08)

2155
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(15 - 4.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.08)

2156
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.3 - 0.1 * Cos(sine / 20)* Player_Size, -0.5* Player_Size) * angles(Rad(0), Rad(75), Rad(0)) * angles(Rad(-6.5), Rad(0), Rad(-20)), 0.08)

2157
                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(-75), Rad(0)) * angles(Rad(-6.5), Rad(0), Rad(20)), 0.08)

2158
                RW.C0 = clerp(RW.C0, CF(1* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, .6* Player_Size) * angles(Rad(-20), Rad(-.6), Rad(-43)), 0.08)

2159
                LW.C0 = clerp(LW.C0, CF(-1 * Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, .6* Player_Size) * angles(Rad(-20), Rad(-.6), Rad(43)), 0.08)

2160
            elseif Mode ~= 6 or Mode ~= 5 or Mode ~= 8 then

2161
                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(3 - 2.5 * Cos(sine / 3.5)), Rad(0) - root.RotVelocity.Y / 75, Rad(8 * Cos(sine / 7))), 0.15)

2162
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(6 - 2.5 * Sin(sine / 7)), Rad(0), Rad(0) - hed.RotVelocity.Y / 15), 0.3)

2163
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.8 - 0.5 * Cos(sine / 7) / 2* Player_Size, 0.6 * Cos(sine / 7) / 2* Player_Size)  * 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)

2164
                    LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.8 + 0.5 * Cos(sine / 7) / 2* Player_Size, -0.6 * Cos(sine / 7) / 2* Player_Size) * 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)

2165
                RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.05 * Sin(sine / 7)* Player_Size, 0* Player_Size) * angles(Rad(37)  * Cos(sine / 7) , Rad(0), Rad(5) - ra.RotVelocity.Y / 75), 0.1)

2166
                LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.05 * Sin(sine / 7)* Player_Size, 0* Player_Size) * angles(Rad(-37)  * Cos(sine / 7) , Rad(0) ,   Rad(-5) + la.RotVelocity.Y / 75), 0.1)

2167
            end

2168
            end

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

2170
            Anim = "Sprint"

2171
            change = 1.35

2172
            if attack == false then

2173
        if Mode == 5 then

2174
            rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, 1 + 0.5 * Player_Size * Cos(sine / 20)) * angles(Rad(45), Rad(0), Rad(0)), 0.15)

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

2176
            RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.3 - 0.1 * Cos(sine / 20)* Player_Size, -.4* Player_Size) * angles(Rad(0), Rad(80), Rad(0)) * angles(Rad(-10.5 + 3.5 * Sin(sine / 20)), Rad(0), Rad(-45)), 0.15)

2177
            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(-80), Rad(0)) * angles(Rad(-10.5 + 3.5 * Sin(sine / 20)), Rad(0), Rad(45)), 0.15)

2178
            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(0), Rad(25)), 0.1)

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

2180
        elseif Mode == 56565 then

2181
            rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.175 + 0.025 * Cos(sine / 3.5) + -Sin(sine / 3.5) / 7) * angles(Rad(26 - 4.5 * Cos(sine / 3.5)), Rad(0) - root.RotVelocity.Y / 75, Rad(15 * Cos(sine / 7))), 0.15)

2182
            tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(-2.5 * Sin(sine / 20)), Rad(0), Rad(0) - hed.RotVelocity.Y / 15), 0.3)

2183
            RH.C0 = clerp(RH.C0, CF(1, -0.925 - 0.5 * Cos(sine / 7) / 2, 0.7 * Cos(sine / 7) / 2) * 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)

2184
            LH.C0 = clerp(LH.C0, CF(-1, -0.925 + 0.5 * Cos(sine / 7) / 2, -0.7 * Cos(sine / 7) / 2) * 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)

2185
            RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 30), 0.34 * Cos(sine / 7)) * angles(Rad(110)  * Cos(sine / 7) , Rad(0), Rad(13) - ra.RotVelocity.Y / 75), 0.15)

2186
            LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 30), -0.34 * Cos(sine / 7)) * angles(Rad(-110)  * Cos(sine / 7) , Rad(0) ,    Rad(-13) + la.RotVelocity.Y / 75), 0.15)

2187
        elseif Mode  == 111111111 then

2188
            rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.175 + 0.025 * Cos(sine / 3.5) + -Sin(sine / 3.5) / 7) * angles(Rad(26 - 4.5 * Cos(sine / 3.5)), Rad(0) - root.RotVelocity.Y / 75, Rad(15 * Cos(sine / 7))), 0.15)

2189
            tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(-2.5 * Sin(sine / 20)), Rad(0), Rad(0) - hed.RotVelocity.Y / 15), 0.3)

2190
            RH.C0 = clerp(RH.C0, CF(1, -0.925 - 0.5 * Cos(sine / 7) / 2, 0.7 * Cos(sine / 7) / 2) * 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)

2191
            LH.C0 = clerp(LH.C0, CF(-1, -0.925 + 0.5 * Cos(sine / 7) / 2, -0.7 * Cos(sine / 7) / 2) * 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)

2192
            RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 30), 0.34 * Cos(sine / 7)) * angles(Rad(110)  * Cos(sine / 7) , Rad(0), Rad(13) - ra.RotVelocity.Y / 75), 0.15)

2193
            LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 30), -0.34 * Cos(sine / 7)) * angles(Rad(-110)  * Cos(sine / 7) , Rad(0) ,    Rad(-13) + la.RotVelocity.Y / 75), 0.15)

2194
        elseif Mode  == 4 then

2195
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, 1.2 + 0.3 * Cos(sine / 20)) * angles(Rad(45), Rad(0), Rad(0)), 0.15)

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

2197
                RH.C0 = clerp(RH.C0, CF(1, -0.4 - 0.1 * Cos(sine / 20), -.4 + 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-2.5 + 3 * Sin(sine / 20)), Rad(0), Rad(-34 + 2.5 * Sin(sine / 20))), 0.15)

2198
                LH.C0 = clerp(LH.C0, CF(-1, -0.9 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * LHCF * angles(Rad(-2.5 + 3 * Sin(sine / 20)), Rad(0), Rad(34 + 2.5 * Sin(sine / 20))), 0.15)

2199
                RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(-55 - 3 * Sin(sine / 20)), Rad(-10 * Sin(sine / 20)), Rad(14 - 2.5 * Sin(sine / 20))), 0.1)

2200
                LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(-55 + 4 * Sin(sine / 20)), Rad(10 * Sin(sine / 20)), Rad(-14 + 2.5 * Sin(sine / 20))), 0.1) 

2201
        elseif Mode == 1 then

2202
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, 1.3 + 0.6 * Cos(sine / 20)) * angles(Rad(65), Rad(0), Rad(0)), 0.15)

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

2204
                RH.C0 = clerp(RH.C0, CF(1, -0.5 - 0.1 * Cos(sine / 20), -.4 + 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-14.5 + 3 * Sin(sine / 20)), Rad(0), Rad(-35 + 3 * Sin(sine / 20))), 0.15)

2205
                LH.C0 = clerp(LH.C0, CF(-1, -0.9 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * LHCF * angles(Rad(-16.5 + 3 * Sin(sine / 20)), Rad(0), Rad(35 + 3 * Sin(sine / 20))), 0.15)

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

2207
                LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 20), 0.025 * Cos(sine / 20)) * angles(Rad(-35), Rad(10 * Cos(sine / 20)), Rad(-25 + 2.5 * Sin(sine / 20))), 0.1)

2208
        elseif Mode == 25 or Mode == 10 then

2209
            rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, 1 + 0.5 * Player_Size * Cos(sine / 20)) * angles(Rad(45), Rad(0), Rad(0)), 0.15)

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

2211
            RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.3 - 0.1 * Cos(sine / 20)* Player_Size, -.4* Player_Size) * angles(Rad(0), Rad(80), Rad(0)) * angles(Rad(-10.5 + 3.5 * Sin(sine / 20)), Rad(0), Rad(-45)), 0.15)

2212
            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(-80), Rad(0)) * angles(Rad(-10.5 + 3.5 * Sin(sine / 20)), Rad(0), Rad(45)), 0.15)

2213
            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(0), Rad(25)), 0.1)

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

2215
        elseif Mode ~= 5 then

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

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

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

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

2220
            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(125)  * Cos(sine / 7) , Rad(0), Rad(5) - ra.RotVelocity.Y / 75), 0.15)

2221
            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(-125)  * Cos(sine / 7) , Rad(0) , Rad(-5) + la.RotVelocity.Y / 75), 0.15)

2222
            end

2223
            end

2224
        end

2225
    end

2226
    Music.SoundId = "rbxassetid://"..SONG

2227
    Music.Looped = true

2228
    Music.Pitch = 1

2229
    Music.Volume = 2.5

2230
    Music.Parent = tors

2231
    Music:Resume()

2232
    if 0 < #Effects then

2233
        for e = 1, #Effects do

2234
            if Effects[e] ~= nil then

2235
                local Thing = Effects[e]

2236
                if Thing ~= nil then

2237
                    local Part = Thing[1]

2238
                    local Mode = Thing[2]

2239
                    local Delay = Thing[3]

2240
                    local IncX = Thing[4]

2241
                    local IncY = Thing[5]

2242
                    local IncZ = Thing[6]

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

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

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

2246
                            local Mesh = Thing[1].Mesh

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

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

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

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

2251
                            local Mesh = Thing[7]

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

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

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

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

2256
                            local Mesh = Thing[7]

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

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

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

2260
                            local Mesh = Thing[1].Mesh

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

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

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

2264
                            local Mesh = Thing[7]

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

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

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

2268
                        elseif Thing[2] == "Elec" then                          local Mesh = Thing[1].Mesh

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

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

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

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

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

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

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

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

2277
                            Thing[6] = Thing[6] + Thing[5]

2278
                        end

2279
                    else

2280
                        Part.Parent = nil

2281
                        table.remove(Effects, e)

2282
                    end

2283
                end

2284
            end

2285
        end

2286
    end

2287
end

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

2289
--End Animations And Script--

2290-
-------------------------------------------------------
2290+
2291
--ROBLOXIDLEANIMATION.Parent = Humanoid

2292
local WEAPONGUI = IT("ScreenGui", PlayerGui)

2293
WEAPONGUI.Name = "Weapon GUI"

2294
local Weapon = IT("Model")

2295
Weapon.Name = "Adds"

2296
local Effects = IT("Folder", Weapon)

2297
Effects.Name = "Effects"

2298
local ANIMATOR = Humanoid.Animator

2299
local ANIMATE = Character.Animate

2300
local UNANCHOR = true

2301
local ENERGYSOUND = 1664710821

2302
local BEAMSOUND = 1417056781

2303
local EXPLOSIONSOUND = 1664711478

2304
2305
--//=================================\\

2306
--\\=================================//

2307
2308
2309
--//=================================\\

2310
--|| SAZERENOS' ARTIFICIAL HEARTBEAT

2311
--\\=================================//

2312
2313
ArtificialHB = Instance.new("BindableEvent", script)

2314
ArtificialHB.Name = "ArtificialHB"

2315
2316
script:WaitForChild("ArtificialHB")

2317
2318
frame = Frame_Speed

2319
tf = 0

2320
allowframeloss = false

2321
tossremainder = false

2322
lastframe = tick()

2323
script.ArtificialHB:Fire()

2324
2325
game:GetService("RunService").Heartbeat:connect(function(s, p)

2326
	tf = tf + s

2327
	if tf >= frame then

2328
		if allowframeloss then

2329
			script.ArtificialHB:Fire()

2330
			lastframe = tick()

2331
		else

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

2333
				script.ArtificialHB:Fire()

2334
			end

2335
		lastframe = tick()

2336
		end

2337
		if tossremainder then

2338
			tf = 0

2339
		else

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

2341
		end

2342
	end

2343
end)

2344
2345
--//=================================\\

2346
--\\=================================//

2347
2348
--//=================================\\

2349
--|| 	      SOME FUNCTIONS

2350
--\\=================================//

2351
2352
function Raycast(POSITION, DIRECTION, RANGE, IGNOREDECENDANTS)

2353
	return workspace:FindPartOnRay(Ray.new(POSITION, DIRECTION.unit * RANGE), IGNOREDECENDANTS)

2354
end

2355
2356
function PositiveAngle(NUMBER)

2357
	if NUMBER >= 0 then

2358
		NUMBER = 0

2359
	end

2360
	return NUMBER

2361
end

2362
2363
function NegativeAngle(NUMBER)

2364
	if NUMBER <= 0 then

2365
		NUMBER = 0

2366
	end

2367
	return NUMBER

2368
end

2369
2370
function Swait(NUMBER)

2371
	if NUMBER == 0 or NUMBER == nil then

2372
		ArtificialHB.Event:wait()

2373
	else

2374
		for i = 1, NUMBER do

2375
			ArtificialHB.Event:wait()

2376
		end

2377
	end

2378
end

2379
2380
function CreateMesh(MESH, PARENT, MESHTYPE, MESHID, TEXTUREID, SCALE, OFFSET)

2381
	local NEWMESH = IT(MESH)

2382
	if MESH == "SpecialMesh" then

2383
		NEWMESH.MeshType = MESHTYPE

2384
		if MESHID ~= "nil" and MESHID ~= "" then

2385
			NEWMESH.MeshId = "http://www.roblox.com/asset/?id="..MESHID

2386
		end

2387
		if TEXTUREID ~= "nil" and TEXTUREID ~= "" then

2388
			NEWMESH.TextureId = "http://www.roblox.com/asset/?id="..TEXTUREID

2389
		end

2390
	end

2391
	NEWMESH.Offset = OFFSET or VT(0, 0, 0)

2392
	NEWMESH.Scale = SCALE

2393
	NEWMESH.Parent = PARENT

2394
	return NEWMESH

2395
end

2396
2397
function CreatePart(FORMFACTOR, PARENT, MATERIAL, REFLECTANCE, TRANSPARENCY, BRICKCOLOR, NAME, SIZE, ANCHOR)

2398
	local NEWPART = IT("Part")

2399
	NEWPART.formFactor = FORMFACTOR

2400
	NEWPART.Reflectance = REFLECTANCE

2401
	NEWPART.Transparency = TRANSPARENCY

2402
	NEWPART.CanCollide = false

2403
	NEWPART.Locked = true

2404
	NEWPART.Anchored = true

2405
	if ANCHOR == false then

2406
		NEWPART.Anchored = false

2407
	end

2408
	NEWPART.BrickColor = BRICKC(tostring(BRICKCOLOR))

2409
	NEWPART.Name = NAME

2410
	NEWPART.Size = SIZE

2411
	NEWPART.Position = Torso.Position

2412
	NEWPART.Material = MATERIAL

2413
	NEWPART:BreakJoints()

2414
	NEWPART.Parent = PARENT

2415
	return NEWPART

2416
end

2417
2418
	local function weldBetween(a, b)

2419
	    local weldd = Instance.new("ManualWeld")

2420
	    weldd.Part0 = a

2421
	    weldd.Part1 = b

2422
	    weldd.C0 = CFrame.new()

2423
	    weldd.C1 = b.CFrame:inverse() * a.CFrame

2424
	    weldd.Parent = a

2425
	    return weldd

2426
	end

2427
2428
2429
function QuaternionFromCFrame(cf)

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

2431
	local trace = m00 + m11 + m22

2432
	if trace > 0 then 

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

2434
		local recip = 0.5 / s

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

2436
	else

2437
		local i = 0

2438
		if m11 > m00 then

2439
			i = 1

2440
		end

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

2442
			i = 2

2443
		end

2444
		if i == 0 then

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

2446
			local recip = 0.5 / s

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

2448
		elseif i == 1 then

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

2450
			local recip = 0.5 / s

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

2452
		elseif i == 2 then

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

2454
			local recip = 0.5 / s return (m02 + m20) * recip, (m12 + m21) * recip, 0.5 * s, (m10 - m01) * recip

2455
		end

2456
	end

2457
end

2458
 

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

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

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

2462
	local xx = x * xs

2463
	local xy = x * ys

2464
	local xz = x * zs

2465
	local yy = y * ys

2466
	local yz = y * zs

2467
	local zz = z * zs

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

2469
end

2470
 

2471
function QuaternionSlerp(a, b, t)

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

2473
	local startInterp, finishInterp;

2474
	if cosTheta >= 0.0001 then

2475
		if (1 - cosTheta) > 0.0001 then

2476
			local theta = ACOS(cosTheta)

2477
			local invSinTheta = 1 / SIN(theta)

2478
			startInterp = SIN((1 - t) * theta) * invSinTheta

2479
			finishInterp = SIN(t * theta) * invSinTheta

2480
		else

2481
			startInterp = 1 - t

2482
			finishInterp = t

2483
		end

2484
	else

2485
		if (1 + cosTheta) > 0.0001 then

2486
			local theta = ACOS(-cosTheta)

2487
			local invSinTheta = 1 / SIN(theta)

2488
			startInterp = SIN((t - 1) * theta) * invSinTheta

2489
			finishInterp = SIN(t * theta) * invSinTheta

2490
		else

2491
			startInterp = t - 1

2492
			finishInterp = t

2493
		end

2494
	end

2495
	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

2496
end

2497
2498
function Clerp(a, b, t)

2499
	local qa = {QuaternionFromCFrame(a)}

2500
	local qb = {QuaternionFromCFrame(b)}

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

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

2503
	local _t = 1 - t

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

2505
end

2506
2507
function CreateFrame(PARENT, TRANSPARENCY, BORDERSIZEPIXEL, POSITION, SIZE, COLOR, BORDERCOLOR, NAME)

2508
	local frame = IT("Frame")

2509
	frame.BackgroundTransparency = TRANSPARENCY

2510
	frame.BorderSizePixel = BORDERSIZEPIXEL

2511
	frame.Position = POSITION

2512
	frame.Size = SIZE

2513
	frame.BackgroundColor3 = COLOR

2514
	frame.BorderColor3 = BORDERCOLOR

2515
	frame.Name = NAME

2516
	frame.Parent = PARENT

2517
	return frame

2518
end

2519
2520
function CreateLabel(PARENT, TEXT, TEXTCOLOR, TEXTFONTSIZE, TEXTFONT, TRANSPARENCY, BORDERSIZEPIXEL, STROKETRANSPARENCY, NAME)

2521
	local label = IT("TextLabel")

2522
	label.BackgroundTransparency = 1

2523
	label.Size = UD2(1, 0, 1, 0)

2524
	label.Position = UD2(0, 0, 0, 0)

2525
	label.TextColor3 = TEXTCOLOR

2526
	label.TextStrokeTransparency = STROKETRANSPARENCY

2527
	label.TextTransparency = TRANSPARENCY

2528
	label.FontSize = TEXTFONTSIZE

2529
	label.Font = TEXTFONT

2530
	label.BorderSizePixel = BORDERSIZEPIXEL

2531
	label.TextScaled = false

2532
	label.Text = TEXT

2533
	label.Name = NAME

2534
	label.Parent = PARENT

2535
	return label

2536
end

2537
2538
function NoOutlines(PART)

2539
	PART.TopSurface, PART.BottomSurface, PART.LeftSurface, PART.RightSurface, PART.FrontSurface, PART.BackSurface = 10, 10, 10, 10, 10, 10

2540
end

2541
2542
function CreateWeldOrSnapOrMotor(TYPE, PARENT, PART0, PART1, C0, C1)

2543
	local NEWWELD = IT(TYPE)

2544
	NEWWELD.Part0 = PART0

2545
	NEWWELD.Part1 = PART1

2546
	NEWWELD.C0 = C0

2547
	NEWWELD.C1 = C1

2548
	NEWWELD.Parent = PARENT

2549
	return NEWWELD

2550
end

2551
2552
local S = IT("Sound")

2553
function CreateSound(ID, PARENT, VOLUME, PITCH, DOESLOOP)

2554
	local NEWSOUND = nil

2555
	coroutine.resume(coroutine.create(function()

2556
		NEWSOUND = S:Clone()

2557
		NEWSOUND.Parent = PARENT

2558
		NEWSOUND.Volume = VOLUME

2559
		NEWSOUND.Pitch = PITCH

2560
		NEWSOUND.SoundId = "http://www.roblox.com/asset/?id="..ID

2561
		NEWSOUND:play()

2562
		if DOESLOOP == true then

2563
			NEWSOUND.Looped = true

2564
		else

2565
			repeat wait(1) until NEWSOUND.Playing == false

2566
			NEWSOUND:remove()

2567
		end

2568
	end))

2569
	return NEWSOUND

2570
end

2571
2572
function CFrameFromTopBack(at, top, back)

2573
	local right = top:Cross(back)

2574
	return CF(at.x, at.y, at.z, right.x, top.x, back.x, right.y, top.y, back.y, right.z, top.z, back.z)

2575
end

2576
2577
--WACKYEFFECT({EffectType = "", Size = VT(1,1,1), Size2 = VT(0,0,0), Transparency = 0, Transparency2 = 1, CFrame = CF(), MoveToPos = nil, RotationX = 0, RotationY = 0, RotationZ = 0, Material = "Neon", Color = C3(1,1,1), SoundID = nil, SoundPitch = nil, SoundVolume = nil})

2578
function WACKYEFFECT(Table)

2579
	local TYPE = (Table.EffectType or "Sphere")

2580
	local SIZE = (Table.Size or VT(1,1,1))

2581
	local ENDSIZE = (Table.Size2 or VT(0,0,0))

2582
	local TRANSPARENCY = (Table.Transparency or 0)

2583
	local ENDTRANSPARENCY = (Table.Transparency2 or 1)

2584
	local CFRAME = (Table.CFrame or Torso.CFrame)

2585
	local MOVEDIRECTION = (Table.MoveToPos or nil)

2586
	local ROTATION1 = (Table.RotationX or 0)

2587
	local ROTATION2 = (Table.RotationY or 0)

2588
	local ROTATION3 = (Table.RotationZ or 0)

2589
	local MATERIAL = (Table.Material or "Neon")

2590
	local COLOR = (Table.Color or C3(1,1,1))

2591
	local TIME = (Table.Time or 45)

2592
	local SOUNDID = (Table.SoundID or nil)

2593
	local SOUNDPITCH = (Table.SoundPitch or nil)

2594
	local SOUNDVOLUME = (Table.SoundVolume or nil)

2595
	coroutine.resume(coroutine.create(function()

2596
		local PLAYSSOUND = false

2597
		local SOUND = nil

2598
		local EFFECT = CreatePart(3, Effects, MATERIAL, 0, TRANSPARENCY, BRICKC("Pearl"), "Effect", VT(1,1,1), true)

2599
		if SOUNDID ~= nil and SOUNDPITCH ~= nil and SOUNDVOLUME ~= nil then

2600
			PLAYSSOUND = true

2601
			SOUND = CreateSound(SOUNDID, EFFECT, SOUNDVOLUME, SOUNDPITCH, false)

2602
		end

2603
		EFFECT.Color = COLOR

2604
		local MSH = nil

2605
		if TYPE == "Sphere" then

2606
			MSH = CreateMesh("SpecialMesh", EFFECT, "Sphere", "", "", SIZE, VT(0,0,0))

2607
		elseif TYPE == "Block" then

2608
			MSH = IT("BlockMesh",EFFECT)

2609
			MSH.Scale = VT(SIZE.X,SIZE.X,SIZE.X)

2610
		elseif TYPE == "Wave" then

2611
			MSH = CreateMesh("SpecialMesh", EFFECT, "FileMesh", "20329976", "", SIZE, VT(0,0,-SIZE.X/8))

2612
		elseif TYPE == "Ring" then

2613
			MSH = CreateMesh("SpecialMesh", EFFECT, "FileMesh", "559831844", "", VT(SIZE.X,SIZE.X,0.1), VT(0,0,0))

2614
		elseif TYPE == "Slash" then

2615
			MSH = CreateMesh("SpecialMesh", EFFECT, "FileMesh", "662586858", "", VT(SIZE.X/10,0,SIZE.X/10), VT(0,0,0))

2616
		elseif TYPE == "Round Slash" then

2617
			MSH = CreateMesh("SpecialMesh", EFFECT, "FileMesh", "662585058", "", VT(SIZE.X/10,0,SIZE.X/10), VT(0,0,0))

2618
		elseif TYPE == "Swirl" then

2619
			MSH = CreateMesh("SpecialMesh", EFFECT, "FileMesh", "1051557", "", SIZE, VT(0,0,0))

2620
		elseif TYPE == "Skull" then

2621
			MSH = CreateMesh("SpecialMesh", EFFECT, "FileMesh", "4770583", "", SIZE, VT(0,0,0))

2622
		elseif TYPE == "Crystal" then

2623
			MSH = CreateMesh("SpecialMesh", EFFECT, "FileMesh", "9756362", "", SIZE, VT(0,0,0))

2624
		end

2625
		if MSH ~= nil then

2626
			local MOVESPEED = nil

2627
			if MOVEDIRECTION ~= nil then

2628
				MOVESPEED = (CFRAME.p - MOVEDIRECTION).Magnitude/TIME

2629
			end

2630
			local GROWTH = SIZE - ENDSIZE

2631
			local TRANS = TRANSPARENCY - ENDTRANSPARENCY

2632
			if TYPE == "Block" then

2633
				EFFECT.CFrame = CFRAME*ANGLES(RAD(MRANDOM(0,360)),RAD(MRANDOM(0,360)),RAD(MRANDOM(0,360)))

2634
			else

2635
				EFFECT.CFrame = CFRAME

2636
			end

2637
			for LOOP = 1, TIME+1 do

2638
				Swait()

2639
				MSH.Scale = MSH.Scale - GROWTH/TIME

2640
				if TYPE == "Wave" then

2641
					MSH.Offset = VT(0,0,-MSH.Scale.X/8)

2642
				end

2643
				EFFECT.Transparency = EFFECT.Transparency - TRANS/TIME

2644
				if TYPE == "Block" then

2645
					EFFECT.CFrame = CFRAME*ANGLES(RAD(MRANDOM(0,360)),RAD(MRANDOM(0,360)),RAD(MRANDOM(0,360)))

2646
				else

2647
					EFFECT.CFrame = EFFECT.CFrame*ANGLES(RAD(ROTATION1),RAD(ROTATION2),RAD(ROTATION3))

2648
				end

2649
				if MOVEDIRECTION ~= nil then

2650
					local ORI = EFFECT.Orientation

2651
					EFFECT.CFrame = CF(EFFECT.Position,MOVEDIRECTION)*CF(0,0,-MOVESPEED)

2652
					EFFECT.Orientation = ORI

2653
				end

2654
			end

2655
			if PLAYSSOUND == false then

2656
				EFFECT:remove()

2657
			else

2658
				repeat Swait() until SOUND.Playing == false

2659
				EFFECT:remove()

2660
			end

2661
		else

2662
			if PLAYSSOUND == false then

2663
				EFFECT:remove()

2664
			else

2665
				repeat Swait() until SOUND.Playing == false

2666
				EFFECT:remove()

2667
			end

2668
		end

2669
	end))

2670
end

2671
2672
function MakeForm(PART,TYPE)

2673
	if TYPE == "Cyl" then

2674
		local MSH = IT("CylinderMesh",PART)

2675
	elseif TYPE == "Ball" then

2676
		local MSH = IT("SpecialMesh",PART)

2677
		MSH.MeshType = "Sphere"

2678
	elseif TYPE == "Wedge" then

2679
		local MSH = IT("SpecialMesh",PART)

2680
		MSH.MeshType = "Wedge"

2681
	end

2682
end

2683
2684
Debris = game:GetService("Debris")

2685
2686
function CastProperRay(StartPos, EndPos, Distance, Ignore)

2687
	local DIRECTION = CF(StartPos,EndPos).lookVector

2688
	return Raycast(StartPos, DIRECTION, Distance, Ignore)

2689
end

2690
2691
function turnto(position)

2692
	RootPart.CFrame=CFrame.new(RootPart.CFrame.p,VT(position.X,RootPart.Position.Y,position.Z)) * CFrame.new(0, 0, 0)

2693
end

2694
2695
--//=================================\\

2696
--||	     WEAPON CREATION

2697
--\\=================================//

2698
2699
local BasePart = CreatePart(3, Weapon, "Marble", 0, 0, "Institutional white", "BraceletPart", VT(1.01,0.3,1.01),false)

2700
CreateWeldOrSnapOrMotor("Weld", RightArm, RightArm, BasePart, CF(0, -0.2, 0) * ANGLES(RAD(0), RAD(0), RAD(0)), CF(0, 0, 0))

2701
for i = 1, 3 do

2702
	local Part = CreatePart(3, Weapon, "Marble", 0, 0, "Daisy orange", "BraceletPart", VT(0.2,1.02,0.2),false)

2703
	CreateWeldOrSnapOrMotor("Weld", BasePart, BasePart, Part, CF(0, 0, 0.6-0.3*i) * ANGLES(RAD(0), RAD(0), RAD(90)), CF(0, 0, 0))

2704
	MakeForm(Part,"Cyl")

2705
end

2706
for i = 1, 3 do

2707
	local Part = CreatePart(3, Weapon, "Marble", 0, 0, "Daisy orange", "BraceletPart", VT(0.2,1.02,0.2),false)

2708
	CreateWeldOrSnapOrMotor("Weld", BasePart, BasePart, Part, CF(0.6-0.3*i, 0, 0) * ANGLES(RAD(0), RAD(90), RAD(90)), CF(0, 0, 0))

2709
	MakeForm(Part,"Cyl")

2710
end

2711
local Part = CreatePart(3, Weapon, "Marble", 0, 0, "Institutional white", "BraceletPart", VT(0.51,0.6,0.25),false)

2712
CreateWeldOrSnapOrMotor("Weld", BasePart, BasePart, Part, CF(-0.125, -0.4, -0.25) * ANGLES(RAD(0), RAD(90), RAD(180)), CF(0, 0, 0))

2713
MakeForm(Part,"Wedge")

2714
local Part = CreatePart(3, Weapon, "Marble", 0, 0, "Institutional white", "BraceletPart", VT(0.51,0.6,0.25),false)

2715
CreateWeldOrSnapOrMotor("Weld", BasePart, BasePart, Part, CF(0.125, -0.4, -0.25) * ANGLES(RAD(0), RAD(-90), RAD(180)), CF(0, 0, 0))

2716
MakeForm(Part,"Wedge")

2717
local Part = CreatePart(3, Weapon, "Marble", 0, 0, "Daisy orange", "BraceletPart", VT(0.52,0.5,0.25/2.3),false)

2718
CreateWeldOrSnapOrMotor("Weld", BasePart, BasePart, Part, CF(-0.125/2.3, -0.25, -0.25) * ANGLES(RAD(0), RAD(90), RAD(180)), CF(0, 0, 0))

2719
MakeForm(Part,"Wedge")

2720
local Part = CreatePart(3, Weapon, "Marble", 0, 0, "Daisy orange", "BraceletPart", VT(0.52,0.5,0.25/2.3),false)

2721
CreateWeldOrSnapOrMotor("Weld", BasePart, BasePart, Part, CF(0.125/2.3, -0.25, -0.25) * ANGLES(RAD(0), RAD(-90), RAD(180)), CF(0, 0, 0))

2722
MakeForm(Part,"Wedge")

2723
2724
for _, c in pairs(Weapon:GetChildren()) do

2725
	if c.ClassName == "Part" then

2726
		c.CustomPhysicalProperties = PhysicalProperties.new(0, 0, 0, 0, 0)

2727
		local AURA = c:Clone()

2728
		AURA:BreakJoints()

2729
		AURA.Parent = c

2730
		AURA.CFrame = c.CFrame

2731
		AURA.Size = AURA.Size*1.001

2732
		AURA.Transparency = 0.3

2733
		AURA.BrickColor = BRICKC"Really red"

2734
		AURA.Material = "Neon"

2735
		weldBetween(c,AURA)

2736
	end

2737
end

2738
2739
local SKILLTEXTCOLOR = BRICKC"Really red".Color

2740
local SKILLFONT = "Bodoni"

2741
local SKILLTEXTSIZE = 7

2742
2743
Weapon.Parent = Character

2744
2745
Humanoid.Died:connect(function()

2746
	ATTACK = true

2747
end)

2748
2749
local SKILL1FRAME = CreateFrame(WEAPONGUI, 0.75, 2, UD2(0.23, 0, 0.80, 0), UD2(0.26, 0, 0.07, 0), C3(0,0,0), C3(0, 0, 0), "Skill 1 Frame")

2750
local SKILL2FRAME = CreateFrame(WEAPONGUI, 0.75, 2, UD2(0.50, 0, 0.80, 0), UD2(0.26, 0, 0.07, 0), C3(0,0,0), C3(0, 0, 0), "Skill 2 Frame")

2751
local SKILL3FRAME = CreateFrame(WEAPONGUI, 0.75, 2, UD2(0.365, 0, 0.90, 0), UD2(0.26, 0, 0.07, 0), C3(0,0,0), C3(0, 0, 0), "Skill 3 Frame")

2752
2753
local SKILL1TEXT = CreateLabel(SKILL1FRAME, "[Z] Aether Beam", SKILLTEXTCOLOR, SKILLTEXTSIZE, SKILLFONT, 0, 2, 1, "Text 1")

2754
local SKILL2TEXT = CreateLabel(SKILL2FRAME, "[B] Aether Explosion", SKILLTEXTCOLOR, SKILLTEXTSIZE, SKILLFONT, 0, 2, 1, "Text 2")

2755
local SKILL3TEXT = CreateLabel(SKILL3FRAME, "[C] Aether Immobilization", SKILLTEXTCOLOR, SKILLTEXTSIZE, SKILLFONT, 0, 2, 1, "Text 3")

2756
2757
--//=================================\\

2758
--||	     DAMAGE FUNCTIONS

2759
--\\=================================//

2760
2761
function StatLabel(CFRAME, TEXT, COLOR)

2762
	local STATPART = CreatePart(3, Effects, "SmoothPlastic", 0, 1, "Really black", "Effect", VT())

2763
	STATPART.CFrame = CF(CFRAME.p,CFRAME.p+VT(MRANDOM(-5,5),MRANDOM(0,5),MRANDOM(-5,5)))

2764
	local BODYGYRO = IT("BodyGyro", STATPART)

2765
	game:GetService("Debris"):AddItem(STATPART ,5)

2766
	local BILLBOARDGUI = Instance.new("BillboardGui", STATPART)

2767
	BILLBOARDGUI.Adornee = STATPART

2768
	BILLBOARDGUI.Size = UD2(2.5, 0, 2.5 ,0)

2769
	BILLBOARDGUI.StudsOffset = VT(-2, 2, 0)

2770
	BILLBOARDGUI.AlwaysOnTop = false

2771
	local TEXTLABEL = Instance.new("TextLabel", BILLBOARDGUI)

2772
	TEXTLABEL.BackgroundTransparency = 1

2773
	TEXTLABEL.Size = UD2(2.5, 0, 2.5, 0)

2774
	TEXTLABEL.Text = TEXT

2775
	TEXTLABEL.Font = SKILLFONT

2776
	TEXTLABEL.FontSize="Size42"

2777
	TEXTLABEL.TextColor3 = COLOR

2778
	TEXTLABEL.TextStrokeTransparency = 0

2779
	TEXTLABEL.TextScaled = true

2780
	TEXTLABEL.TextWrapped = true

2781
	coroutine.resume(coroutine.create(function(THEPART, THEBODYPOSITION, THETEXTLABEL)

2782
		for i = 1, 50 do

2783
			Swait()

2784
			STATPART.CFrame = STATPART.CFrame * CF(0,0,-0.2)

2785
			TEXTLABEL.TextTransparency = TEXTLABEL.TextTransparency + (1/50)

2786
			TEXTLABEL.TextStrokeTransparency = TEXTLABEL.TextTransparency

2787
		end

2788
		THEPART.Parent = nil

2789
	end),STATPART, TEXTLABEL)

2790
end

2791
2792
--//=================================\\

2793
--||			DAMAGING

2794
--\\=================================//

2795
2796
function ApplyDamage(Humanoid,Damage,TorsoPart)

2797
	local defence = Instance.new("BoolValue",Humanoid.Parent)

2798
	defence.Name = ("HitBy"..Player.Name)

2799
	game:GetService("Debris"):AddItem(defence, 0.001)

2800
	Damage = Damage * DAMAGEMULTIPLIER

2801
	if Humanoid.Health ~= 0 then

2802
		local CritChance = MRANDOM(1,100)

2803
		if Damage > Humanoid.Health then

2804
			Damage = math.ceil(Humanoid.Health)

2805
			if Damage == 0 then

2806
				Damage = 0.1

2807
			end

2808
		end

2809
		Humanoid.Health = Humanoid.Health - Damage

2810
		StatLabel(TorsoPart.CFrame * CF(0, 0 + (TorsoPart.Size.z - 1), 0), Damage, C3(0, 0, 0))

2811
	end

2812
end

2813
2814
function ApplyAoE(POSITION,RANGE,MINDMG,MAXDMG,FLING,STUNS)

2815
	local CHILDREN = workspace:GetDescendants()

2816
	for index, CHILD in pairs(CHILDREN) do

2817
		if CHILD.ClassName == "Model" and CHILD ~= Character then

2818
			local HUM = CHILD:FindFirstChildOfClass("Humanoid")

2819
			if HUM then

2820
				local TORSO = CHILD:FindFirstChild("Torso") or CHILD:FindFirstChild("UpperTorso")

2821
				if TORSO then

2822
					if (TORSO.Position - POSITION).Magnitude <= RANGE then

2823
						if STUNS == true then

2824
							coroutine.resume(coroutine.create(function()

2825
								if HUM:FindFirstChild("StunValue") == nil then

2826
									StatLabel(TORSO.CFrame * CF(0, 0 + (TORSO.Size.z - 1), 0), "Stunned!", C3(1,1,1))

2827
									HUM.PlatformStand = true

2828
									local STUNVALUE = IT("NumberValue",HUM)

2829
									STUNVALUE.Name = "StunValue"

2830
									STUNVALUE.Value = 8

2831
									repeat wait(1) STUNVALUE.Value = STUNVALUE.Value - 1 until STUNVALUE.Value <= 0

2832
									HUM.PlatformStand = false

2833
									STUNVALUE:remove()

2834
								else

2835
									HUM.StunValue.Value = 8

2836
								end

2837
							end))

2838
						end

2839
						local DMG = MRANDOM(MINDMG,MAXDMG)

2840
						ApplyDamage(HUM,DMG,TORSO)

2841
						if FLING > 0 then

2842
							for _, c in pairs(CHILD:GetChildren()) do

2843
								if c:IsA("BasePart") then

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

2845
									bv.maxForce = Vector3.new(1e9, 1e9, 1e9)

2846
									bv.velocity = CF(POSITION,TORSO.Position).lookVector*FLING

2847
									bv.Parent = c

2848
									Debris:AddItem(bv,0.05)

2849
								end

2850
							end

2851
						end

2852
					end

2853
				end

2854
			end

2855
		end

2856
	end

2857
end

2858
2859
--//=================================\\

2860
--||	ATTACK FUNCTIONS AND STUFF

2861
--\\=================================//

2862
2863
function Charge(TIME,GYRO)

2864
	local SND = CreateSound(ENERGYSOUND,Torso,6,TIME,false)

2865
	local G = nil

2866
	if GYRO == true then

2867
		G = IT("BodyGyro",RootPart)

2868
		G.D = 250

2869
		G.P = 200000

2870
		G.MaxTorque = VT(math.huge,math.huge,math.huge)

2871
	end

2872
	for i=0, TIME, 0.1 / Animation_Speed do

2873
		Swait()

2874
		if G then

2875
			G.cframe = CF(RootPart.Position,Mouse.Hit.p)

2876
		end

2877
		WACKYEFFECT({TIME = 25, EffectType = "Sphere", Size = VT(1.2,1.2,1.2), Size2 = VT(0,0,0), Transparency = 0.5, Transparency2 = 1, CFrame = BasePart.CFrame, MoveToPos = BasePart.CFrame*ANGLES(RAD(MRANDOM(0,360)),RAD(MRANDOM(0,360)),RAD(MRANDOM(0,360)))*CF(0,0,-4).p, RotationX = 0, RotationY = 0, RotationZ = 0, Material = "Neon", Color = SKILLTEXTCOLOR, SoundID = nil, SoundPitch = nil, SoundVolume = nil})

2878
		RootJoint.C0 = Clerp(RootJoint.C0,ROOTC0 * CF(0, 0, 0 + 0.05 * COS(SINE / 12)) * ANGLES(RAD(0), RAD(0), RAD(0)), 0.15 / Animation_Speed)

2879
		Neck.C0 = Clerp(Neck.C0, NECKC0 * CF(0, 0, 0 + ((1) - 1)) * ANGLES(RAD(15 - 2.5 * SIN(SINE / 12)), RAD(0), RAD(0)), 0.15 / Animation_Speed)

2880
		RightShoulder.C0 = Clerp(RightShoulder.C0, CF(1.25, 0.5, -0.5) * ANGLES(RAD(90), RAD(0), RAD(-45)) * RIGHTSHOULDERC0, 2 / Animation_Speed)

2881
		LeftShoulder.C0 = Clerp(LeftShoulder.C0, CF(-1.25, 0.5, -0.5) * ANGLES(RAD(90), RAD(0), RAD(45)) * LEFTSHOULDERC0, 2 / Animation_Speed)

2882
		RightHip.C0 = Clerp(RightHip.C0, CF(1, -1 - 0.05 * COS(SINE / 12), -0.01) * ANGLES(RAD(0), RAD(90), RAD(0)) * ANGLES(RAD(-8), RAD(0), RAD(0)), 0.15 / Animation_Speed)

2883
		LeftHip.C0 = Clerp(LeftHip.C0, CF(-1, -1 - 0.05 * COS(SINE / 12), -0.01) * ANGLES(RAD(0), RAD(-90), RAD(0)) * ANGLES(RAD(-8), RAD(0), RAD(0)), 0.15 / Animation_Speed)

2884
	end

2885
	SND:remove()

2886
	if G then

2887
		return G

2888
	end

2889
end

2890
2891
function Aether_Beam()

2892
	ATTACK = true

2893
	Rooted = false

2894
	local GRAV = IT("BodyPosition",RootPart)

2895
	GRAV.D = 75

2896
	GRAV.P = 20000

2897
	GRAV.MaxForce = VT(math.huge,math.huge,math.huge)

2898
	GRAV.Position = RootPart.Position

2899
	local GYRO = Charge(2,true)

2900
	local BEAM = CreatePart(3, Effects, "Neon", 0, 0, "Really red", "Beam", VT(25,25,0))

2901
	MakeForm(BEAM,"Ball")

2902
	CreateSound(BEAMSOUND,BEAM,10,1,false)

2903
	CreateSound(BEAMSOUND,BEAM,10,0.9,false)

2904
	CreateSound(BEAMSOUND,BEAM,10,0.8,false)

2905
	for i = 1, 250 do

2906
		Swait()

2907
		BEAM.Size = BEAM.Size + VT(-0.1,-0.1,2)

2908
		ApplyAoE(BEAM.CFrame*CF(0,0,-BEAM.Size.Z/2).p,BEAM.Size.Y/2,5,8,125,false)

2909
		WACKYEFFECT({TIME = 25, EffectType = "Sphere", Size = VT(3,3,3), Size2 = VT(0,0,0), Transparency = 0.5, Transparency2 = 1, CFrame = BEAM.CFrame*CF(0,0,BEAM.Size.Z/2), MoveToPos = BEAM.CFrame*CF(0,0,BEAM.Size.Z/2)*ANGLES(RAD(90),RAD(MRANDOM(0,360)),RAD(0))*CF(0,0.3,-25).p, RotationX = 0, RotationY = 0, RotationZ = 0, Material = "Neon", Color = SKILLTEXTCOLOR, SoundID = nil, SoundPitch = nil, SoundVolume = nil})

2910
		BEAM.CFrame = CF(Torso.Position,Torso.CFrame*CF(0,0,-1).p)*CF(0,0,-2-(BEAM.Size.Z/2))

2911
		RootJoint.C0 = Clerp(RootJoint.C0,ROOTC0 * CF(0, 0, 0 + 0.05 * COS(SINE / 12)) * ANGLES(RAD(0), RAD(0), RAD(0)), 0.15 / Animation_Speed)

2912
		Neck.C0 = Clerp(Neck.C0, NECKC0 * CF(0, 0, 0 + ((1) - 1)) * ANGLES(RAD(0 - 2.5 * SIN(SINE / 12)), RAD(0), RAD(0)), 0.15 / Animation_Speed)

2913
		RightShoulder.C0 = Clerp(RightShoulder.C0, CF(1.5, 0.5, -0.5) * ANGLES(RAD(90), RAD(0), RAD(12)) * RIGHTSHOULDERC0, 2 / Animation_Speed)

2914
		LeftShoulder.C0 = Clerp(LeftShoulder.C0, CF(-1.5, 0.5, -0.5) * ANGLES(RAD(90), RAD(0), RAD(-12)) * LEFTSHOULDERC0, 2 / Animation_Speed)

2915
		RightHip.C0 = Clerp(RightHip.C0, CF(1, -1 - 0.05 * COS(SINE / 12), -0.01) * ANGLES(RAD(0), RAD(90), RAD(0)) * ANGLES(RAD(-8), RAD(0), RAD(0)), 0.15 / Animation_Speed)

2916
		LeftHip.C0 = Clerp(LeftHip.C0, CF(-1, -1 - 0.05 * COS(SINE / 12), -0.01) * ANGLES(RAD(0), RAD(-90), RAD(0)) * ANGLES(RAD(-8), RAD(0), RAD(0)), 0.15 / Animation_Speed)

2917
	end

2918
	GRAV:remove()

2919
	BEAM:remove()

2920
	GYRO:remove()

2921
	ATTACK = false

2922
	Rooted = false

2923
end

2924
2925
function Aether_Explosion()

2926
	ATTACK = true

2927
	Rooted = true

2928
	for i=0, 1, 0.1 / Animation_Speed do

2929
		Swait()

2930
		RootJoint.C0 = Clerp(RootJoint.C0,ROOTC0 * CF(0, -0.3, 0) * ANGLES(RAD(0), RAD(0), RAD(-75)), 0.6 / Animation_Speed)

2931
		Neck.C0 = Clerp(Neck.C0, NECKC0 * CF(0, 0, 0 + ((1) - 1)) * ANGLES(RAD(0), RAD(0), RAD(75)), 0.6 / Animation_Speed)

2932
		RightShoulder.C0 = Clerp(RightShoulder.C0, CF(1.5, 0.5, 0) * ANGLES(RAD(90), RAD(0), RAD(15)) * RIGHTSHOULDERC0, 0.3 / Animation_Speed)

2933
		LeftShoulder.C0 = Clerp(LeftShoulder.C0, CF(-1.5, 0.5, 0) * ANGLES(RAD(0), RAD(0), RAD(-90)) * LEFTSHOULDERC0, 0.1 / Animation_Speed)

2934
		RightHip.C0 = Clerp(RightHip.C0, CF(1, -1, -0.01) * ANGLES(RAD(0), RAD(90), RAD(0)) * ANGLES(RAD(-15), RAD(0), RAD(0)), 0.5 / Animation_Speed)

2935
		LeftHip.C0 = Clerp(LeftHip.C0, CF(-1, -1, -0.01) * ANGLES(RAD(0), RAD(-90), RAD(0)) * ANGLES(RAD(-15), RAD(0), RAD(0)), 0.5 / Animation_Speed)

2936
	end

2937
	for i=0, 0.4, 0.1 / Animation_Speed do

2938
		Swait()

2939
		RootJoint.C0 = Clerp(RootJoint.C0,ROOTC0 * CF(0, -1, -0.3) * ANGLES(RAD(75), RAD(0), RAD(75)), 1 / Animation_Speed)

2940
		Neck.C0 = Clerp(Neck.C0, NECKC0 * CF(0, 0, 0 + ((1) - 1)) * ANGLES(RAD(0), RAD(0), RAD(-75)), 1/ Animation_Speed)

2941
		RightShoulder.C0 = Clerp(RightShoulder.C0, CF(1.5, 0.5, 0) * ANGLES(RAD(0), RAD(0), RAD(90)) * RIGHTSHOULDERC0, 1 / Animation_Speed)

2942
		LeftShoulder.C0 = Clerp(LeftShoulder.C0, CF(-1.5, 0.5, 0) * ANGLES(RAD(0), RAD(0), RAD(0)) * LEFTSHOULDERC0, 1 / Animation_Speed)

2943
		RightHip.C0 = Clerp(RightHip.C0, CF(1, -0.5, -0.01) * ANGLES(RAD(75), RAD(25), RAD(0)) * ANGLES(RAD(-35), RAD(0), RAD(0)), 1 / Animation_Speed)

2944
		LeftHip.C0 = Clerp(LeftHip.C0, CF(-1, -1, -0.01) * ANGLES(RAD(0), RAD(-90), RAD(0)) * ANGLES(RAD(-15), RAD(0), RAD(0)), 1 / Animation_Speed)

2945
	end

2946
	local BEAM = CreatePart(3, Effects, "Neon", 0, 0, "Really red", "Beam", VT(0,0,0))

2947
	local BEAM2 = CreatePart(3, Effects, "Neon", 0, 0, "Really red", "Beam", VT(0,0,0))

2948
	MakeForm(BEAM,"Ball")

2949
	MakeForm(BEAM2,"Ball")

2950
	BEAM.CFrame = CF(RootPart.Position)

2951
	BEAM2.CFrame = CF(RootPart.Position)

2952
	CreateSound(EXPLOSIONSOUND,RootPart,10,1,false)

2953
	for i=1, 100 do

2954
		Swait()

2955
		BEAM.Size = BEAM.Size + VT(0.9,8,0.9)

2956
		BEAM2.Size = BEAM2.Size + VT(3,3,3)

2957
		ApplyAoE(BEAM2.Position,BEAM2.Size.Z/2,1,1,15,false)

2958
		BEAM.CFrame = CF(RootPart.Position)

2959
		BEAM2.CFrame = CF(RootPart.Position)

2960
		WACKYEFFECT({TIME = 5+i, EffectType = "Swirl", Size = BEAM2.Size*1.15, Size2 = VT(0,BEAM.Size.Y,0), Transparency = 0.8, Transparency2 = 1, CFrame = BEAM.CFrame * ANGLES(RAD(0), RAD(i*5), RAD(0)), MoveToPos = nil, RotationX = 0, RotationY = i/8, RotationZ = 0, Material = "Neon", Color = SKILLTEXTCOLOR, SoundID = nil, SoundPitch = nil, SoundVolume = nil})

2961
		RootJoint.C0 = Clerp(RootJoint.C0,ROOTC0 * CF(0, -1, -0.3) * ANGLES(RAD(75), RAD(0), RAD(75)), 1 / Animation_Speed)

2962
		Neck.C0 = Clerp(Neck.C0, NECKC0 * CF(0, 0, 0 + ((1) - 1)) * ANGLES(RAD(0), RAD(0), RAD(-75)), 1/ Animation_Speed)

2963
		RightShoulder.C0 = Clerp(RightShoulder.C0, CF(1.5, 0.5, 0) * ANGLES(RAD(0), RAD(0), RAD(90)) * RIGHTSHOULDERC0, 1 / Animation_Speed)

2964
		LeftShoulder.C0 = Clerp(LeftShoulder.C0, CF(-1.5, 0.5, 0) * ANGLES(RAD(0), RAD(0), RAD(0)) * LEFTSHOULDERC0, 1 / Animation_Speed)

2965
		RightHip.C0 = Clerp(RightHip.C0, CF(1, -0.5, -0.01) * ANGLES(RAD(75), RAD(25), RAD(0)) * ANGLES(RAD(-35), RAD(0), RAD(0)), 1 / Animation_Speed)

2966
		LeftHip.C0 = Clerp(LeftHip.C0, CF(-1, -1, -0.01) * ANGLES(RAD(0), RAD(-90), RAD(0)) * ANGLES(RAD(-15), RAD(0), RAD(0)), 1 / Animation_Speed)

2967
	end

2968
	WACKYEFFECT({TIME = 75, EffectType = "Sphere", Size = BEAM.Size, Size2 = VT(0,BEAM.Size.Y,0), Transparency = 0, Transparency2 = 0, CFrame = BEAM.CFrame, MoveToPos = nil, RotationX = 0, RotationY = 0, RotationZ = 0, Material = "Neon", Color = SKILLTEXTCOLOR, SoundID = nil, SoundPitch = nil, SoundVolume = nil})

2969
	WACKYEFFECT({TIME = 75, EffectType = "Sphere", Size = BEAM2.Size, Size2 = VT(0,0,0), Transparency = 0, Transparency2 = 0.6, CFrame = BEAM2.CFrame, MoveToPos = nil, RotationX = 0, RotationY = 0, RotationZ = 0, Material = "Neon", Color = SKILLTEXTCOLOR, SoundID = nil, SoundPitch = nil, SoundVolume = nil})

2970
	BEAM2:remove()

2971
	BEAM:remove()

2972
	ATTACK = false

2973
	Rooted = false

2974
end

2975
2976
function Aether_Immobilization()

2977
	ATTACK = true

2978
	Rooted = true

2979
	Charge(5,false)

2980
	local SND = CreateSound(EXPLOSIONSOUND,RootPart,10,1,false)

2981
	local SND2 = CreateSound(ENERGYSOUND,RootPart,10,1,false)

2982
	for i = 1, 230 do

2983
		Swait()

2984
		ApplyAoE(RootPart.Position,i*1.3,0.5,0.5,-200,true)

2985
		SND.Pitch = 1

2986
		SND2.Pitch = 1

2987
		WACKYEFFECT({TIME = 4, EffectType = "Wave", Size = VT(i*2,10,i*2), Size2 = VT(i*2,10,i*2), Transparency = 0.9, Transparency2 = 1, CFrame = CF(RootPart.Position-VT(0,3,0)) * ANGLES(RAD(0), RAD(i*5), RAD(0)), MoveToPos = nil, RotationX = 0, RotationY = i/8, RotationZ = 0, Material = "Neon", Color = SKILLTEXTCOLOR, SoundID = nil, SoundPitch = nil, SoundVolume = nil})

2988
		WACKYEFFECT({TIME = math.ceil(15-(i/10)), EffectType = "Wave", Size = VT(0,10,0), Size2 = VT(i*2,6,i*2), Transparency = 0.8, Transparency2 = 1, CFrame = CF(RootPart.Position-VT(0,3,0)) * ANGLES(RAD(0), RAD(i*5), RAD(0)), MoveToPos = nil, RotationX = 0, RotationY = i/8, RotationZ = 0, Material = "Neon", Color = SKILLTEXTCOLOR, SoundID = nil, SoundPitch = nil, SoundVolume = nil})

2989
		WACKYEFFECT({TIME = math.ceil(15-(i/10)), EffectType = "Wave", Size = VT(0,6,0), Size2 = VT(i*1.6,10,i*1.6), Transparency = 0.8, Transparency2 = 1, CFrame = CF(RootPart.Position-VT(0,3,0)) * ANGLES(RAD(MRANDOM(-5,5)), RAD(i*5), RAD(MRANDOM(-5,5))), MoveToPos = nil, RotationX = 0, RotationY = i/8, RotationZ = 0, Material = "Neon", Color = SKILLTEXTCOLOR, SoundID = nil, SoundPitch = nil, SoundVolume = nil})

2990
		RootJoint.C0 = Clerp(RootJoint.C0,ROOTC0 * CF(0, 0, 0 + 0.05 * COS(SINE / 12)) * ANGLES(RAD(0), RAD(0), RAD(0)), 1 / Animation_Speed)

2991
		Neck.C0 = Clerp(Neck.C0, NECKC0 * CF(0, 0, 0 + ((1) - 1)) * ANGLES(RAD(-15 - 2.5 * SIN(SINE / 12)), RAD(0), RAD(0)), 1 / Animation_Speed)

2992
		RightShoulder.C0 = Clerp(RightShoulder.C0, CF(1.5, 0.5, 0) * ANGLES(RAD(-45), RAD(-45), RAD(45)) * RIGHTSHOULDERC0, 1 / Animation_Speed)

2993
		LeftShoulder.C0 = Clerp(LeftShoulder.C0, CF(-1.5, 0.5, 0) * ANGLES(RAD(-45), RAD(45), RAD(-45)) * LEFTSHOULDERC0, 1 / Animation_Speed)

2994
		RightHip.C0 = Clerp(RightHip.C0, CF(1, -1 - 0.05 * COS(SINE / 12), -0.01) * ANGLES(RAD(0), RAD(65), RAD(0)) * ANGLES(RAD(-8), RAD(0), RAD(0)), 1 / Animation_Speed)

2995
		LeftHip.C0 = Clerp(LeftHip.C0, CF(-1, -1 - 0.05 * COS(SINE / 12), -0.01) * ANGLES(RAD(0), RAD(-65), RAD(0)) * ANGLES(RAD(-8), RAD(0), RAD(0)), 1 / Animation_Speed)

2996
	end

2997
	SND:remove()

2998
	SND2:remove()

2999
	ATTACK = false

3000
	Rooted = false

3001
end

3002
3003
--//=================================\\

3004
--||	  ASSIGN THINGS TO KEYS

3005
--\\=================================//

3006
3007
function MouseDown(Mouse)

3008
	if ATTACK == false then

3009
	end

3010
end

3011
3012
function MouseUp(Mouse)

3013
HOLD = false

3014
end

3015
3016
function KeyDown(Key)

3017
	KEYHOLD = true

3018
	if Key == "z" and ATTACK == false then

3019
		Aether_Beam()

3020
	end

3021
3022
	if Key == "b" and ATTACK == false then

3023
		Aether_Explosion()

3024
	end

3025
3026
	if Key == "c" and ATTACK == false then

3027
		Aether_Immobilization()

3028
	end

3029
end

3030
3031
function KeyUp(Key)

3032
	KEYHOLD = false

3033
end

3034
3035
	Mouse.Button1Down:connect(function(NEWKEY)

3036
		MouseDown(NEWKEY)

3037
	end)

3038
	Mouse.Button1Up:connect(function(NEWKEY)

3039
		MouseUp(NEWKEY)

3040
	end)

3041
	Mouse.KeyDown:connect(function(NEWKEY)

3042
		KeyDown(NEWKEY)

3043
	end)

3044
	Mouse.KeyUp:connect(function(NEWKEY)

3045
		KeyUp(NEWKEY)

3046
	end)

3047
3048
--//=================================\\

3049
--\\=================================//

3050
3051
function unanchor()

3052
	if UNANCHOR == true then

3053
		g = Character:GetChildren()

3054
		for i = 1, #g do

3055
			if g[i].ClassName == "Part" then

3056
				g[i].Anchored = false

3057
			end

3058
		end

3059
	end

3060
end

3061
3062
--//=================================\\

3063
--||	WRAP THE WHOLE SCRIPT UP

3064
--\\=================================//

3065
3066
Humanoid.Changed:connect(function(Jump)

3067
	if Jump == "Jump" and (Disable_Jump == true) then

3068
		Humanoid.Jump = false

3069
	end

3070
end)

3071
3072
while true do

3073
	Swait()

3074
	script.Parent = WEAPONGUI

3075
	ANIMATE.Parent = nil

3076
	if Humanoid then

3077
		local IDLEANIMATION = Humanoid:LoadAnimation(ROBLOXIDLEANIMATION)

3078
		IDLEANIMATION:Play()

3079
	end

3080
	SINE = SINE + CHANGE

3081
	local TORSOVELOCITY = (RootPart.Velocity * VT(1, 0, 1)).magnitude

3082
	local TORSOVERTICALVELOCITY = RootPart.Velocity.y

3083
	local HITFLOOR = Raycast(RootPart.Position, (CF(RootPart.Position, RootPart.Position + VT(0, -1, 0))).lookVector, 4, Character)

3084
	local WALKSPEEDVALUE = 5 / (Humanoid.WalkSpeed / 16)

3085
	if ANIM == "Walk" and TORSOVELOCITY > 1 then

3086
		RootJoint.C1 = Clerp(RootJoint.C1, ROOTC0 * CF(0, 0, -0.15 * COS(SINE / (WALKSPEEDVALUE / 2))) * ANGLES(RAD(0), RAD(0) - RootPart.RotVelocity.Y / 75, RAD(0)), 2 * (Humanoid.WalkSpeed / 16) / Animation_Speed)

3087
		Neck.C1 = Clerp(Neck.C1, CF(0, -0.5, 0) * ANGLES(RAD(-90), RAD(0), RAD(180)) * ANGLES(RAD(2.5 * SIN(SINE / (WALKSPEEDVALUE / 2))), RAD(0), RAD(0) - Head.RotVelocity.Y / 30), 0.2 * (Humanoid.WalkSpeed / 16) / Animation_Speed)

3088
		RightHip.C1 = Clerp(RightHip.C1, CF(0.5, 0.875 - 0.125 * SIN(SINE / WALKSPEEDVALUE) - 0.15 * COS(SINE / WALKSPEEDVALUE*2), -0.125 * COS(SINE / WALKSPEEDVALUE) +0.2+ 0.2 * COS(SINE / WALKSPEEDVALUE)) * ANGLES(RAD(0), RAD(90), RAD(0)) * ANGLES(RAD(0) - RightLeg.RotVelocity.Y / 75, RAD(0), RAD(45 * COS(SINE / WALKSPEEDVALUE))), 1 / Animation_Speed)

3089
		LeftHip.C1 = Clerp(LeftHip.C1, CF(-0.5, 0.875 + 0.125 * SIN(SINE / WALKSPEEDVALUE) - 0.15 * COS(SINE / WALKSPEEDVALUE*2), 0.125 * COS(SINE / WALKSPEEDVALUE) +0.2+ -0.2 * COS(SINE / WALKSPEEDVALUE)) * ANGLES(RAD(0), RAD(-90), RAD(0)) * ANGLES(RAD(0) + LeftLeg.RotVelocity.Y / 75, RAD(0), RAD(45 * COS(SINE / WALKSPEEDVALUE))), 1 / Animation_Speed)

3090
	elseif (ANIM ~= "Walk") or (TORSOVELOCITY < 1) then

3091
		RootJoint.C1 = Clerp(RootJoint.C1, ROOTC0 * CF(0, 0, 0) * ANGLES(RAD(0), RAD(0), RAD(0)), 0.2 / Animation_Speed)

3092
		Neck.C1 = Clerp(Neck.C1, CF(0, -0.5, 0) * ANGLES(RAD(-90), RAD(0), RAD(180)) * ANGLES(RAD(0), RAD(0), RAD(0)), 0.2 / Animation_Speed)

3093
		RightHip.C1 = Clerp(RightHip.C1, CF(0.5, 1, 0) * ANGLES(RAD(0), RAD(90), RAD(0)) * ANGLES(RAD(0), RAD(0), RAD(0)), 0.2 / Animation_Speed)

3094
		LeftHip.C1 = Clerp(LeftHip.C1, CF(-0.5, 1, 0) * ANGLES(RAD(0), RAD(-90), RAD(0)) * ANGLES(RAD(0), RAD(0), RAD(0)), 0.2 / Animation_Speed)

3095
	end

3096
	if TORSOVERTICALVELOCITY > 1 and HITFLOOR == nil then

3097
		ANIM = "Jump"

3098
		if ATTACK == false then

3099
			RootJoint.C0 = Clerp(RootJoint.C0, ROOTC0 * CF(0, 0, 0) * ANGLES(RAD(0), RAD(0), RAD(0)), 0.2 / Animation_Speed)

3100
			Neck.C0 = Clerp(Neck.C0, NECKC0 * CF(0, 0, 0 + ((1) - 1)) * ANGLES(RAD(-20), RAD(0), RAD(0)), 0.2 / Animation_Speed)

3101
			RightShoulder.C0 = Clerp(RightShoulder.C0, CF(1.5, 0.5, 0) * ANGLES(RAD(-40), RAD(0), RAD(20)) * RIGHTSHOULDERC0, 0.2 / Animation_Speed)

3102
			LeftShoulder.C0 = Clerp(LeftShoulder.C0, CF(-1.5, 0.5, 0) * ANGLES(RAD(-40), RAD(0), RAD(-20)) * LEFTSHOULDERC0, 0.2 / Animation_Speed)

3103
			RightHip.C0 = Clerp(RightHip.C0, CF(1, -1, -0.3) * ANGLES(RAD(0), RAD(90), RAD(0)) * ANGLES(RAD(-5), RAD(0), RAD(-20)), 0.2 / Animation_Speed)

3104
			LeftHip.C0 = Clerp(LeftHip.C0, CF(-1, -1, -0.3) * ANGLES(RAD(0), RAD(-90), RAD(0)) * ANGLES(RAD(-5), RAD(0), RAD(20)), 0.2 / Animation_Speed)

3105
	    end

3106
	elseif TORSOVERTICALVELOCITY < -1 and HITFLOOR == nil then

3107
		ANIM = "Fall"

3108
		if ATTACK == false then

3109
			RootJoint.C0 = Clerp(RootJoint.C0, ROOTC0 * CF(0, 0, 0 ) * ANGLES(RAD(0), RAD(0), RAD(0)), 0.2 / Animation_Speed)

3110
			Neck.C0 = Clerp(Neck.C0, NECKC0 * CF(0, 0 , 0 + ((1) - 1)) * ANGLES(RAD(20), RAD(0), RAD(0)), 0.2 / Animation_Speed)

3111
			RightShoulder.C0 = Clerp(RightShoulder.C0, CF(1.5, 0.5, 0) * ANGLES(RAD(0), RAD(0), RAD(60)) * RIGHTSHOULDERC0, 0.2 / Animation_Speed)

3112
			LeftShoulder.C0 = Clerp(LeftShoulder.C0, CF(-1.5, 0.5, 0) * ANGLES(RAD(0), RAD(0), RAD(-60)) * LEFTSHOULDERC0, 0.2 / Animation_Speed)

3113
			RightHip.C0 = Clerp(RightHip.C0, CF(1, -1, 0) * ANGLES(RAD(0), RAD(90), RAD(0)) * ANGLES(RAD(0), RAD(0), RAD(20)), 0.2 / Animation_Speed)

3114
			LeftHip.C0 = Clerp(LeftHip.C0, CF(-1, -1, 0) * ANGLES(RAD(0), RAD(-90), RAD(0)) * ANGLES(RAD(0), RAD(0), RAD(10)), 0.2 / Animation_Speed)

3115
		end

3116
	elseif TORSOVELOCITY < 1 and HITFLOOR ~= nil then

3117
		ANIM = "Idle"

3118
		if ATTACK == false then

3119
			RootJoint.C0 = Clerp(RootJoint.C0,ROOTC0 * CF(0, 0, 0 + 0.05 * COS(SINE / 12)) * ANGLES(RAD(0), RAD(0), RAD(0)), 0.15 / Animation_Speed)

3120
			Neck.C0 = Clerp(Neck.C0, NECKC0 * CF(0, 0, 0 + ((1) - 1)) * ANGLES(RAD(0 - 2.5 * SIN(SINE / 12)), RAD(0), RAD(0)), 0.15 / Animation_Speed)

3121
			RightShoulder.C0 = Clerp(RightShoulder.C0, CF(1.5, 0.5, 0) * ANGLES(RAD(0), RAD(0), RAD(12)) * RIGHTSHOULDERC0, 0.15 / Animation_Speed)

3122
			LeftShoulder.C0 = Clerp(LeftShoulder.C0, CF(-1.5, 0.5, 0) * ANGLES(RAD(0), RAD(0), RAD(-12)) * LEFTSHOULDERC0, 0.15 / Animation_Speed)

3123
			RightHip.C0 = Clerp(RightHip.C0, CF(1, -1 - 0.05 * COS(SINE / 12), -0.01) * ANGLES(RAD(0), RAD(90), RAD(0)) * ANGLES(RAD(-8), RAD(0), RAD(0)), 0.15 / Animation_Speed)

3124
			LeftHip.C0 = Clerp(LeftHip.C0, CF(-1, -1 - 0.05 * COS(SINE / 12), -0.01) * ANGLES(RAD(0), RAD(-90), RAD(0)) * ANGLES(RAD(-8), RAD(0), RAD(0)), 0.15 / Animation_Speed)

3125
		end

3126
	elseif TORSOVELOCITY > 1 and HITFLOOR ~= nil then

3127
		ANIM = "Walk"

3128
		if ATTACK == false then

3129
			RootJoint.C0 = Clerp(RootJoint.C0,ROOTC0 * CF(0, 0, -0.1) * ANGLES(RAD(5), RAD(0), RAD(0)), 0.15 / Animation_Speed)

3130
			Neck.C0 = Clerp(Neck.C0, NECKC0 * CF(0, 0, 0 + ((1) - 1)) * ANGLES(RAD(5 - 8 * SIN(SINE / (WALKSPEEDVALUE / 2))), RAD(0), RAD(0)), 0.15 / Animation_Speed)

3131
			RightShoulder.C0 = Clerp(RightShoulder.C0, CF(1.5, 0.5, 0.15 * SIN(SINE / WALKSPEEDVALUE)) * ANGLES(RAD(25 * COS(SINE / WALKSPEEDVALUE)), RAD(0), RAD(5)) * RIGHTSHOULDERC0, 1 / Animation_Speed)

3132
			LeftShoulder.C0 = Clerp(LeftShoulder.C0, CF(-1.5, 0.5, -0.15 * SIN(SINE / WALKSPEEDVALUE)) * ANGLES(RAD(-25 * COS(SINE / WALKSPEEDVALUE)), RAD(0), RAD(-5)) * LEFTSHOULDERC0, 1 / Animation_Speed)

3133
			RightHip.C0 = Clerp(RightHip.C0, CF(1 , -1, 0) * ANGLES(RAD(0), RAD(90), RAD(0)) * ANGLES(RAD(0), RAD(0), RAD(-15)), 2 / Animation_Speed)

3134
			LeftHip.C0 = Clerp(LeftHip.C0, CF(-1, -1, 0) * ANGLES(RAD(0), RAD(-90), RAD(0)) * ANGLES(RAD(0), RAD(0), RAD(15)), 2 / Animation_Speed)

3135
		end

3136
	end

3137
	unanchor()

3138
	Humanoid.MaxHealth = "inf"

3139
	Humanoid.Health = "inf"

3140
	if Rooted == false then

3141
		Disable_Jump = false

3142
		Humanoid.WalkSpeed = Speed

3143
	elseif Rooted == true then

3144
		Disable_Jump = true

3145
		Humanoid.WalkSpeed = 0

3146
	end

3147
end

3148
3149
--//=================================\\

3150
--\\=================================//

3151
3152
3153
3154
3155
3156
--//====================================================\\--

3157
--||			  		 END OF SCRIPT

3158
--\\====================================================//--
        

    


            


                                


        

            



                
    

        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!