using GorillaExtensions;

using GorillaGameModes;
using GorillaNetworking;
using GorillaTag;
using GorillaTagScripts;
using [Link];
using [Link];
using [Link];
using [Link];
using OVR;
using [Link];
using [Link];
using [Link];
using [Link];
using PlayFab;
using [Link];
using [Link];
using System;
using [Link];
using [Link];
using [Link];
using [Link];
using UnityEngine;
using static [Link];
using static [Link];

namespace [Link]
{
public class Fun
{
public static void FixHead()
{
[Link].x = 0f;
[Link].y = 0f;
[Link].z = 0f;
}

public static void UpsideDownHead() =>

[Link].z = 180f;

public static void BrokenNeck() =>

[Link].z = 90f;

public static void BackwardsHead() =>

[Link].y = 180f;

public static void SidewaysHead() =>

[Link].y = 90f;

public static void RandomYHeadSpaz() =>

[Link].y =
[Link](20, 340);

public static void RandomYHead() =>

[Link].y =
[Link](20, 340);

public static float lastBangTime;

public static float BPM = 159f;
 public static void HeadBang()
{
if ([Link] > lastBangTime)
{
[Link].x = 50f;
lastBangTime = [Link] + (60f/BPM);
}
else
[Link].x =
[Link]([Link].x,0f,0.1f);
}

public static void SpinHeadX()

{
if ([Link])
[Link].x += 10f;
else
[Link] =
[Link]([Link] + new
Vector3(10f, 0f, 0f));
}

public static void SpinHeadY()

{
if ([Link])
[Link].y += 10f;
else
[Link] =
[Link]([Link] + new
Vector3(0f, 10f, 0f));
}

public static void SpinHeadZ()

{
if ([Link])
[Link].z += 10f;
else
[Link] =
[Link]([Link] + new
Vector3(0f, 0f, 10f));
}

public static void FlipHands()

{
Vector3 lh = [Link];
Vector3 rh = [Link];
Quaternion lhr = [Link];
Quaternion rhr = [Link];

[Link] =
lh;

[Link] =
rh;

[Link] =
lhr;
[Link] =
rhr;
}

public static void FixHandTaps()

{
[Link] = false;
[Link] = true;
[Link] = false;
[Link] = 0.1f;
[Link] = 1;
[Link] = 0.1f;
}

public static void LoudHandTaps()

{
[Link] = true;
[Link] = true;
[Link] = true;
[Link] = 99999f;
[Link] = 10;
[Link] = 99999f;
}

public static void SilentHandTaps()

{
[Link] = true;
[Link] = false;
[Link] = false;
[Link] = 0f;
[Link] = 0;
[Link] = 0;
}

public static void SilentHandTapsOnTag()

{
if (PlayerIsTagged([Link]))
SilentHandTaps();
else
FixHandTaps();
}

private static float instantPartyDelay = 0f;

public static void InstantParty()
{
if ([Link] > instantPartyDelay)
{
instantPartyDelay = [Link] + 0.1f;

[Link] = 0f;
[Link] = 0f;

List<int> provisionalMembers =
[Link];

if ([Link] > 0)
{
 Color targetColor =
[Link]([Link]);
[Link] =
targetColor;

List<int> members = new List<int>

{ [Link] };
foreach (Player player in [Link])
{
if
([Link]([Link]) ||
[Link]([Link]))
[Link]([Link]);
}

[Link]([Link]
olor(targetColor), [Link](), false);
RPCProtection();
}
}
}

public static void KickAllInParty()

{
if ([Link])
{
partyLastCode = [Link];
waitForPlayerJoin = false;

[Link]([Link]
(), [Link]);
partyTime = [Link] + 0.25f;
phaseTwo = false;
amountPartying =
[Link] - 1;

[Link]("<color=grey>[</color><color=purple>PARTY</
color><color=grey>]</color> <color=white>Kicking " + [Link]() + "
party members, this may take a second...</color>");
}
else

[Link]("<color=grey>[</color><color=red>ERROR</
color><color=grey>]</color> <color=white>You are not in a party!</color>");
}

public static void BanAllInParty()

{
if ([Link])
{
partyLastCode = [Link];
waitForPlayerJoin = true;
[Link]("KKK",
[Link]);
partyTime = [Link] + 0.25f;
phaseTwo = false;
amountPartying =
[Link] - 1;
[Link]("<color=grey>[</color><color=purple>PARTY</
color><color=grey>]</color> <color=white>Banning " + [Link]() + "
party members, this may take a second...</color>");
}
else

[Link]("<color=grey>[</color><color=red>ERROR</
color><color=grey>]</color> <color=white>You are not in a party!</color>");
}

public static Coroutine partyKickDelayCoroutine;

public static IEnumerator PartyKickDelay(bool ban)
{
yield return new WaitForSeconds(0.25f);

if (ban)
BanAllInParty();
else
KickAllInParty();

Coroutine thisCoroutine = partyKickDelayCoroutine;

partyKickDelayCoroutine = null;

[Link](thisCoroutine);
}

public static bool lastPartyKickThingy = false;

public static void AutoPartyKick()
{
if ([Link] && !
lastPartyKickThingy)
partyKickDelayCoroutine ??=
[Link](PartyKickDelay(false));

lastPartyKickThingy = [Link];
}

public static void AutoPartyBan()

{
if ([Link] && !
lastPartyKickThingy)
partyKickDelayCoroutine ??=
[Link](PartyKickDelay(true));

lastPartyKickThingy = [Link];
}

public static float splashDel;

public static void WaterSplashHands()
{
if ([Link] > splashDel && (rightGrab || leftGrab))
{
[Link]("RPC_PlaySplashEffect",
[Link], new object[]
{
rightGrab ?
[Link] :
[Link],
rightGrab ?
[Link] :
[Link],
4f,
100f,
true,
false
});
RPCProtection();
splashDel = [Link] + 0.1f;
}
}

public static void WaterSplashAura()

{
if ([Link] > splashDel)
{
[Link]("RPC_PlaySplashEffect",
[Link], new object[]
{
[Link] + new
Vector3([Link](-0.5f, 0.5f),[Link](-0.5f,
0.5f),[Link](-0.5f, 0.5f)),
RandomQuaternion(),
4f,
100f,
true,
false
});
RPCProtection();
splashDel = [Link] + 0.1f;
}
}

public static void OrbitWaterSplash()

{
if ([Link] > splashDel)
{
[Link]("RPC_PlaySplashEffect",
[Link], new object[]
{
[Link] + new
Vector3([Link]((float)[Link] / 30), 1f,
[Link]((float)[Link] / 30)),
RandomQuaternion(),
4f,
100f,
true,
false
});
RPCProtection();
splashDel = [Link] + 0.1f;
}
}

public static void WaterSplashGun()

{
if (GetGunInput(false))
{
var GunData = RenderGun();
 RaycastHit Ray = [Link];
GameObject NewPointer = [Link];

if (GetGunInput(true))
{
[Link] = false;
[Link] =
[Link] - new Vector3(0, 1, 0);
if ([Link] > splashDel)
{

[Link]("RPC_PlaySplashEffect", [Link], new

object[]
{
[Link],
RandomQuaternion(),
4f,
100f,
true,
false
});
RPCProtection();
splashDel = [Link] + 0.1f;
}
}
else
[Link] = true;
}
}

public static void WaterSplashWalk()

{
if ([Link] > splashDel)
{
if ([Link](true))
{
RaycastHit ray =
[Link];
[Link]("RPC_PlaySplashEffect",
[Link], new object[]
{
[Link],
[Link]([Link]),
4f,
100f,
true,
false
});
RPCProtection();
splashDel = [Link] + 0.1f;
}
if ([Link](false))
{
RaycastHit ray =
[Link];
[Link]("RPC_PlaySplashEffect",
[Link], new object[]
{
[Link],
 [Link]([Link]),
4f,
100f,
true,
false
});
RPCProtection();
splashDel = [Link] + 0.1f;
}
}
}

private static bool lastlhboop = false;

private static bool lastrhboop = false;
public static void Boop(int sound = 84)
{
bool isBoopLeft = false;
bool isBoopRight = false;
foreach (VRRig vrrig in [Link])
{
if (vrrig != [Link])
{
float D1 =
[Link]([Link],
[Link]);
float D2 =
[Link]([Link],
[Link]);

float threshold = 0.275f;

if (!isBoopLeft)
isBoopLeft = D1 < threshold;

if (!isBoopRight)
isBoopRight = D2 < threshold;
}
}
if (isBoopLeft && !lastlhboop)
{
if ([Link])
{
[Link]("RPC_PlayHandTap",
[Link], new object[]{
sound,
true,
999999f
});
RPCProtection();
}
else
[Link](sound, true, 999999f);
}
if (isBoopRight && !lastrhboop)
{
if ([Link])
{
[Link]("RPC_PlayHandTap",
[Link], new object[]{
 sound,
false,
999999f
});
RPCProtection();
}
else
[Link](sound, false, 999999f);
}
lastlhboop = isBoopLeft;
lastrhboop = isBoopRight;
}

private static bool autoclickstate = false;

public static void AutoClicker()
{
autoclickstate = !autoclickstate;
if (leftTrigger > 0.5f)
{
[Link] =
autoclickstate ? 1f : 0f;

[Link] = autoclickstate ? 1f : 0f;

[Link](1f);
}
if (rightTrigger > 0.5f)
{
[Link] =
autoclickstate ? 1f : 0f;

[Link] = autoclickstate ? 1f : 0f;

[Link](1f);
}
}

public static List<object[]> keyLogs = new List<object[]> { };

public static bool keyboardTrackerEnabled = false;
public static void KeyboardTracker()
{
keyboardTrackerEnabled = true;
if ([Link] > 0)
{
foreach (object[] keylog in keyLogs)
{
if ([Link] > (float)keylog[2])
{

[Link]("<color=grey>[</color><color=purple>KEYLOGS</
color><color=grey>]</color> " + (string)keylog[1], 5000);
[Link](keylog);
}
}
}
}

public static void PreloadTagSounds()

{
string[] sounds = new string[]
{
 "firstblood",
"doublekill",
"triplekill",
"killingspree",
"wickedsick",
"monsterkill",
"rampage"
};

foreach (string sound in sounds)

LoadSoundFromURL($"[Link]
main/killsounds/{sound}.wav", $"{sound}.wav");
}

private static float muteDelay = 0f;

public static void MuteGun()
{
if (GetGunInput(false))
{
var GunData = RenderGun();
RaycastHit Ray = [Link];
GameObject NewPointer = [Link];

if (GetGunInput(true) && [Link] > muteDelay)

{
VRRig gunTarget = [Link]<VRRig>();
if (gunTarget && !PlayerIsLocal(gunTarget))
{
foreach (GorillaPlayerScoreboardLine line in
[Link])
{
if ([Link] == GetPlayerFromVRRig(gunTarget))
{
muteDelay = [Link] + 0.5f;
[Link](![Link],
[Link]);
}
}
}
}
}
}

public static void MuteAll()

{
foreach (GorillaPlayerScoreboardLine line in
[Link])
{
if (![Link])
[Link](true,
[Link]);
}
}

public static void UnmuteAll()

{
foreach (GorillaPlayerScoreboardLine line in
[Link])
{
 if ([Link])
[Link](false,
[Link]);
}
}

public static void MuteDJSets()

{
foreach (RadioButtonGroupWearable djSet in
GetAllType<RadioButtonGroupWearable>())
{
if ([Link])
[Link] = false;
}
}

public static void UnmuteDJSets()

{
foreach (RadioButtonGroupWearable djSet in
GetAllType<RadioButtonGroupWearable>())
{
if (![Link])
[Link] = true;
}
}

public static void SetDebugEchoMode(bool value)

{
if (![Link])
[Link] = value;
}

public static void CopyVoiceGun()

{
if (GetGunInput(false))
{
var GunData = RenderGun();
RaycastHit Ray = [Link];
GameObject NewPointer = [Link];

if (gunLocked && lockTarget != null)

{
AudioClip clippy =
[Link]<GorillaSpeakerLoudness>().[Link]
Component<AudioSource>().clip;
if ([Link] != clippy)
[Link] = clippy;
}
if (GetGunInput(true))
{
VRRig gunTarget = [Link]<VRRig>();
if (gunTarget && !PlayerIsLocal(gunTarget))
{
gunLocked = true;
lockTarget = gunTarget;
[Link] =
[Link];
[Link] =
[Link]<GorillaSpeakerLoudness>().[Link]
Component<AudioSource>().clip;
[Link](true);
[Link] = true;
}
}
}
else
{
if (gunLocked)
{
gunLocked = false;
[Link]();
}
}
}

private static float tapDelay = 0f;

public static void TapAllClass<T>() where T : Tappable
{
if (rightGrab)
{
if ([Link] > tapDelay)
{
foreach (Tappable TappableObject in GetAllType<T>())
[Link](1f);

RPCProtection();
tapDelay = [Link] + 0.1f;
}
}
}

private static float buttonDelay;

public static void ActivateAllDoors()
{
if (rightGrab)
{
if ([Link] > buttonDelay)
{
foreach (GhostLabButton button in GetAllType<GhostLabButton>())
{
[Link]();
RPCProtection();
}
buttonDelay = [Link] + 0.1f;
}
}
}

private static float hitDelay = 0f;

public static void AutoHitMoleType(bool isHazard)
{
foreach (Mole mole in GetAllType<Mole>())
{
int state = [Link];
if ([Link]() && [Link][state].isHazard == isHazard &&
[Link] > hitDelay)
{
hitDelay = [Link] + 0.1f;
 [Link](1f);
RPCProtection();
}
}
}

private static float moleMachineDelay;

public static void SpazMoleMachines()
{
if ([Link] > moleMachineDelay)
{
moleMachineDelay = [Link] + 0.25f;
foreach (WhackAMole moleMachine in GetAllType<WhackAMole>())
{
[Link]("WhackAMoleButtonPressed",
[Link], new object[] { });
RPCProtection();
}
}
}

public static void AutoStartMoles()

{
if ([Link] > moleMachineDelay)
{
moleMachineDelay = [Link] + 0.1f;
foreach (WhackAMole moleMachine in GetAllType<WhackAMole>())
{
if ([Link] == [Link] ||
[Link] == [Link])
{
[Link]("WhackAMoleButtonPressed",
[Link], new object[] { });
RPCProtection();
}
}
}
}

public static void SetBraceletState(bool enable, bool isLeftHand) =>

[Link]("EnableNonCosmeticHandItemRPC",
[Link], new object[]
{
enable,
isLeftHand
});

public static void GetBracelet(bool state)

{
if (leftGrab)
{
SetBraceletState(false, false);
SetBraceletState(state, true);
}

if (rightGrab)
{
SetBraceletState(state, false);
 SetBraceletState(false, true);
}

if (leftGrab || rightGrab)
RPCProtection();
}

public static void BraceletSpam() => GetBracelet([Link] % 2 == 0);

public static void RemoveBracelet()

{
SetBraceletState(false, true);
SetBraceletState(false, false);
RPCProtection();
}

public static void RainbowBracelet()

{
[Link] = true;
if (![Link])
{
SetBraceletState(true, false);
RPCProtection();

[Link](true);
}
List<Color> rgbColors = new List<Color> { };
for (int i=0; i<10; i++)
[Link]([Link]((([Link] / 180f) + (i / 10f))
% 1f, 1f, 1f));

[Link] = false;
[Link] = 99;
[Link] = rgbColors;
[Link](rgbColors, 99);
}

public static void RemoveRainbowBracelet()

{
[Link] = false;
if (![Link])
{
SetBraceletState(false, false);
RPCProtection();

[Link](false);
}

[Link] = false;
[Link] = 0;
[Link]();
[Link]();
}

public static void GiveBuilderWatch()

{
[Link](true);
RPCProtection();
}
 public static void RemoveBuilderWatch()
{
[Link](false);
RPCProtection();
}

private static float lastTimeDingied = 0f;

public static void QuestNoises()
{
if (rightTrigger > 0.5f && [Link] > lastTimeDingied)
{
lastTimeDingied = [Link] + 0.12f;
[Link]("Environment
Objects/LocalObjects_Prefab/City_WorkingPrefab/CosmeticsRoomAnchor/
outsidestores_prefab/Bottom Layer/OutsideBuildings/Wardrobe
Hut/MonkeBusinessStation").GetComponent<PhotonView>().RPC("BroadcastRedeemQuestPoin
ts", [Link], [Link](0, 50));
}
}

private static float delaybetweenscore = 0f;

public static void MaxQuestScore()
{
if ([Link] > delaybetweenscore)
{
delaybetweenscore = [Link] + 1f;
[Link]([Link]);
}
}

public static void FakeFPS()

{
[Link] = true;
[Link] = [Link](0, 255);
}

public static void EverythingGrabbable()

{
[Link](false);
foreach (GameEntity entity in
[Link])
{
if (entity != null)
{
try
{
[Link] = -1;
[Link] = true;
} catch { }
}
}
}

public static void GrabIDCard()

{
if (rightGrab)
{
GamePlayer plr = [Link];
 if ([Link]([Link](false)) == null)
{
foreach (GRBadge grBadge in
[Link]("GhostReactorRoot/GhostReactorZone/GhostReactorEmployeeBadges").Get
Component<GRUIStationEmployeeBadges>().registeredBadges)
{
GameEntity entity = [Link];
if ([Link] ==
[Link])
{
[Link] = false;
[Link] =
[Link];

[Link]([Link], false,
[Link], [Link]);
}
}
}
}
else
{
[Link] = true;
}
}

public static void SetPropDistanceLimit(float distance)

{
if ([Link] && [Link]() ==
[Link])
{
GorillaPropHuntGameManager hauntManager =
(GorillaPropHuntGameManager)[Link];
hauntManager.m_ph_hand_follow_distance = distance;
}
}

private static float purchaseDelay;

public static void PurchaseAllToolStations()
{
if ([Link] > purchaseDelay)
{

[Link]([Link](0,
[Link] - 1),
[Link]);
purchaseDelay = [Link] + 0.1f;
}
}

public static void SetCurrencySelf(int currency = 0)

{
if (![Link]) { return; }
[Link]([Link]).currency =
currency;
}
 public static void SetCurrencyGun(int currency = 0)
{
if (GetGunInput(false))
{
var GunData = RenderGun();
RaycastHit Ray = [Link];
GameObject NewPointer = [Link];

if (GetGunInput(true))
{
VRRig gunTarget = [Link]<VRRig>();
if (gunTarget && !PlayerIsLocal(gunTarget))
{
if ([Link])

[Link](GetPlayerFromVRRig(gunTarget).ActorNumber).currency = currency;
else

[Link]("<color=grey>[</color><color=red>ERROR</
color><color=grey>]</color> <color=white>You are not master client.</color>");
}
}
}
}

public static void SetCurrencyAll(int currency = 0)

{
if (![Link])
{ [Link]("<color=grey>[</color><color=red>ERROR</
color><color=grey>]</color> <color=white>You are not master client.</color>");
return; }

foreach (Player target in [Link])

{
GRPlayer plr = [Link]([Link]);
[Link] = currency;
}
}

public static void RemoveCurrencySelf()

{
if (![Link]) { return; }
[Link]([Link]).currency = 0;
}

public static void RemoveCurrencyGun()

{
if (GetGunInput(false))
{
var GunData = RenderGun();
RaycastHit Ray = [Link];
GameObject NewPointer = [Link];

if (GetGunInput(true))
{
VRRig gunTarget = [Link]<VRRig>();
if (gunTarget && !PlayerIsLocal(gunTarget))
{
if ([Link])
[Link](GetPlayerFromVRRig(gunTarget).ActorNumber).currency = 0;
else

[Link]("<color=grey>[</color><color=red>ERROR</
color><color=grey>]</color> <color=white>You are not master client.</color>");
}
}
}
}

public static void RemoveCurrencyAll()

{
if (![Link])
{ [Link]("<color=grey>[</color><color=red>ERROR</
color><color=grey>]</color> <color=white>You are not master client.</color>");
return; }

foreach (Player target in [Link])

{
GRPlayer plr = [Link]([Link]);
[Link] = 0;
}
}

public static void Invincibility()

{
if (![Link])
{ [Link]("<color=grey>[</color><color=red>ERROR</
color><color=grey>]</color> <color=white>You are not master client.</color>");
return; }

GRPlayer plr = [Link]([Link]);

if ([Link] == [Link])
[Link](plr,
[Link]);

[Link] = [Link];
}

public static void SetPlayerState(Player Target, [Link]

State)
{
GRPlayer GRPlayer = [Link]([Link]);

if ([Link] == State)
return;

if ((Target == [Link] && State ==

[Link])
|| ([Link] && State ==
[Link])
)
{
[Link](GRPlayer,
State);
RPCProtection();
return;
 }

if (![Link])
{ [Link]("<color=grey>[</color><color=red>ERROR</
color><color=grey>]</color> <color=white>You are not master client.</color>");
return; }

if (State == [Link])
[Link](KillTarget(Target));
}

public static void SetPlayerState(NetPlayer Target, [Link]

State) =>
SetPlayerState(NetPlayerToPlayer(Target), State);

public static void SetPlayerState(VRRig Target, [Link]

State) =>
SetPlayerState(NetPlayerToPlayer(GetPlayerFromVRRig(Target)), State);

public static IEnumerator KillTarget(Player Target)

{
GRPlayer GRPlayer = [Link]([Link]);
VRRig Rig = GetVRRigFromPlayer(Target);

int netId =
[Link]();

[Link]("CreateItemRPC",
Target, new object[]
{
new int[] { netId },
new int[] { (int)[Link] },
new int[] { 48354877 },
new long[]
{ [Link]([Link]) },
new int[]
{ [Link]([Link]) },
new long[] { 0L }
});

[Link]("ApplyBehaviorRPC",
Target, new object[]
{
new int[] { netId },
new byte[] { 6 }
});

[Link]([Link],
[Link]);

RPCProtection();

yield return null;

yield return null;
yield return null;
[Link]("DestroyItemRPC",
Target, new object[]
{
new int[] { netId }
});

RPCProtection();
}

private static float killDelay;

public static void SetStateSelf(int state) =>
SetPlayerState([Link],
([Link])state);

public static void SetStateAll(int state)

{
foreach (Player target in [Link])
SetPlayerState(target, ([Link])state);
}

public static void SetStateGun(int state)

{
if (GetGunInput(false))
{
var GunData = RenderGun();
RaycastHit Ray = [Link];
GameObject NewPointer = [Link];

if (GetGunInput(true))
{
VRRig gunTarget = [Link]<VRRig>();
if (gunTarget && !PlayerIsLocal(gunTarget))
SetPlayerState(gunTarget, ([Link])state);
}
}
}

public static void SpazKillSelf()

{
if ([Link] > killDelay)
{
killDelay = [Link] + 0.1f;

GRPlayer plr = [Link]([Link]);

SetPlayerState([Link], [Link] ==
[Link] ? [Link] :
[Link]);
}
}

public static void SpazKillGun()

{
if (GetGunInput(false))
{
var GunData = RenderGun();
RaycastHit Ray = [Link];
GameObject NewPointer = [Link];

if (GetGunInput(true))
 {
VRRig gunTarget = [Link]<VRRig>();
if (gunTarget && !PlayerIsLocal(gunTarget) && [Link] >
killDelay)
{
killDelay = [Link] + 0.1f;
GRPlayer plr =
[Link](GetPlayerFromVRRig(gunTarget).ActorNumber);
SetPlayerState(gunTarget, [Link] ==
[Link] ? [Link] :
[Link]);
}
}
}
}

public static void SpazKillAll()

{
if ([Link] > killDelay)
{
foreach (Player target in [Link])
{
killDelay = [Link] + 0.1f;

GRPlayer plr = [Link]([Link]);

SetPlayerState(target, [Link] ==
[Link] ? [Link] :
[Link]);
}
}
}

public static void SpazToolStations()

{
if ([Link] > purchaseDelay)
{

[Link]([Link](0,
[Link] - 1),
([Link])[Link](0, 2));
purchaseDelay = [Link] + 0.1f;
}
}

public static void SetMicrophoneQuality(int bitrate, int samplingRate)

{
Recorder mic = [Link];
[Link] = (SamplingRate)samplingRate;
[Link] = bitrate;

[Link](true);
}

public static void SetMicrophoneAmplification(bool amplify)

{
Recorder mic = [Link];

if (amplify)
{
 MicAmplifier microphoneAmplifier =
[Link]<MicAmplifier>();
[Link] = 16;
[Link] = 16;
} else
{
if ([Link]<MicAmplifier>())

[Link]([Link]<MicAmplifier>());
}

[Link](true);
}

public static void ReloadMicrophone() =>

[Link](true);

public static void ObjectToPointGun(string objectName)

{
if (GetGunInput(false))
{
var GunData = RenderGun();
RaycastHit Ray = [Link];
GameObject NewPointer = [Link];

if (GetGunInput(true))
{
[Link](objectName).[Link] =
[Link] + new Vector3(0f, 1f, 0f);
}
}
}

public static void GliderGun()

{
if (GetGunInput(false))
{
var GunData = RenderGun();
RaycastHit Ray = [Link];
GameObject NewPointer = [Link];

if (GetGunInput(true))
{
foreach (GliderHoldable glider in GetAllType<GliderHoldable>())
{
if ([Link] == [Link])
{
[Link] =
[Link] + new Vector3(0f, 1f, 0f);
} else
{
[Link](null, null);
}
}
}
}
}

private static float lastReceivedTime = 0f;

 private static List<BuilderPiece> archivepiecesfiltered = new
List<BuilderPiece>() { };
public static BuilderPiece[] GetPiecesFiltered()
{
if ([Link] > lastReceivedTime)
{
archivepiecesfiltered = null;
lastReceivedTime = [Link] + 5f;
}
if (archivepiecesfiltered == null)
{
archivepiecesfiltered = new List<BuilderPiece>() { };
foreach (BuilderPiece piece in GetAllType<BuilderPiece>())
{
if ([Link] > 0)
[Link](piece);
}
}
return [Link]();
}

private static int pieceIdSet = -566818631;

private static float blockDelay = 0f;
public static void BlocksGun()
{
if (GetGunInput(false))
{
var GunData = RenderGun();
RaycastHit Ray = [Link];
GameObject NewPointer = [Link];

if (GetGunInput(true))
{
RequestCreatePiece(pieceIdSet, [Link] +
new Vector3(0f, 1f, 0f), [Link], 0);
RPCProtection();
}
}
}

private static float gbgd = 0f;

public static void SelectBlockGun()
{
if (GetGunInput(false))
{
var GunData = RenderGun();
RaycastHit Ray = [Link];
GameObject NewPointer = [Link];

if (GetGunInput(true))
{
BuilderPiece gunTarget =
[Link]<BuilderPiece>();
if (gunTarget && [Link] > gbgd)
{
gbgd = [Link] + 0.1f;
pieceIdSet = [Link];

[Link]("<color=grey>[</color><color=green>SUCCESS</
color><color=grey>]</color> Successfully selected piece " +
[Link]("(Clone)", "") + "!");
RPCProtection();
}
}
}
}

public static void NoRespawnBug()

{
[Link]("Floating Bug
Holdable").GetComponent<ThrowableBug>().maxDistanceFromOriginBeforeRespawn =
[Link];
[Link]("Floating Bug
Holdable").GetComponent<ThrowableBug>().maxDistanceFromTargetPlayerBeforeRespawn =
[Link];
}

public static void DisableNoRespawnBug()

{
[Link]("Floating Bug
Holdable").GetComponent<ThrowableBug>().maxDistanceFromOriginBeforeRespawn = 50f;
[Link]("Floating Bug
Holdable").GetComponent<ThrowableBug>().maxDistanceFromTargetPlayerBeforeRespawn =
50f;
}

public static void NoRespawnBat()

{
[Link]("Cave Bat
Holdable").GetComponent<ThrowableBug>().maxDistanceFromOriginBeforeRespawn =
[Link];
[Link]("Cave Bat
Holdable").GetComponent<ThrowableBug>().maxDistanceFromTargetPlayerBeforeRespawn =
[Link];
}

public static void DisableNoRespawnBat()

{
[Link]("Cave Bat
Holdable").GetComponent<ThrowableBug>().maxDistanceFromOriginBeforeRespawn = 50f;
[Link]("Cave Bat
Holdable").GetComponent<ThrowableBug>().maxDistanceFromTargetPlayerBeforeRespawn =
50f;
}

public static void FastSnowballs()

{
foreach (SnowballMaker Maker in new[] { [Link],
[Link] })
{
foreach (SnowballThrowable Throwable in [Link])
{
[Link] = 10f;
[Link] = 99999f;
[Link] = 99999f;
}
}
}
 public static void SlowSnowballs()
{
foreach (SnowballMaker Maker in new[] { [Link],
[Link] })
{
foreach (SnowballThrowable Throwable in [Link])
{
[Link] = 0.2f;
[Link] = 6f;
[Link] = 2f;
}
}
}

public static void FixSnowballs()

{
foreach (SnowballMaker Maker in new[] { [Link],
[Link] })
{
foreach (SnowballThrowable Throwable in [Link])
{
[Link] = 1f;
[Link] = 12f;
[Link] = 4f;
}
}
}

// These mods are kind of suggestive

// I've seen way more graphic stuff on other menus so don't you come at me
for my suggestive mods
public static void SnowballButtocks()
{
[Link] = false;

[Link] =
[Link] + new Vector3(0f, 0.15f,
0f);
[Link] =
[Link];
[Link] =
[Link];

[Link] =
[Link] + [Link](
new Vector3(-0.0436f, -0.3f, -0.1563f)
);
[Link] =
[Link] + [Link](
new Vector3(-0.0072f, -0.2964f, -0.1563f)
);

[Link] =
[Link] * [Link](330f, 344.5f, 0f);
[Link] =
[Link] * [Link](340f, 165.5f, 160f);

[Link] = 1f;
 [Link] = 1f;
[Link] = 1f;

[Link](1f, false);
[Link](1f, false);
[Link](1f, false);

[Link] = 1f;
[Link] = 1f;
[Link] = 1f;

[Link](1f, false);
[Link](1f, false);
[Link](1f, false);

GrowingSnowballThrowable LeftHandSnowball =
GetProjectile("GrowingSnowballLeftAnchor") as GrowingSnowballThrowable;
if (![Link])
{
[Link](true);
[Link](3);

[Link](true,
[Link]);
[Link]([Link]);
}

GrowingSnowballThrowable RightHandSnowball =
GetProjectile("GrowingSnowballRightAnchor") as GrowingSnowballThrowable;
if (![Link])
{
[Link](true);
[Link](3);

[Link](false,
[Link]);
[Link]([Link]);
}
}

public static void SnowballBreasts()

{
[Link] = false;

[Link] =
[Link] + new Vector3(0f, 0.15f,
0f);
[Link] =
[Link];
[Link] =
[Link];

[Link] =
[Link] + [Link](
new Vector3(-0.08f, -0.0691f, 0f)
);
[Link] =
[Link] + [Link](
new Vector3(-0.0073f, -0.2182f, 0.0164f)
 );

[Link] =
[Link] * [Link](350f, 140f, 62f);
[Link] =
[Link] * [Link](8f, 30f, 8f);

[Link] = 1f;
[Link] = 1f;
[Link] = 1f;

[Link](1f, false);
[Link](1f, false);
[Link](1f, false);

[Link] = 1f;
[Link] = 1f;
[Link] = 1f;

[Link](1f, false);
[Link](1f, false);
[Link](1f, false);

GrowingSnowballThrowable LeftHandSnowball =
GetProjectile("GrowingSnowballLeftAnchor") as GrowingSnowballThrowable;
if (![Link])
{
[Link](true);
[Link](3);

[Link](true,
[Link]);
[Link]([Link]);
}

GrowingSnowballThrowable RightHandSnowball =
GetProjectile("GrowingSnowballRightAnchor") as GrowingSnowballThrowable;
if (![Link])
{
[Link](true);
[Link](3);

[Link](false,
[Link]);
[Link]([Link]);
}
}

public static void DisableSnowballGenitals()

{
[Link] = true;

GetProjectile("GrowingSnowballLeftAnchor").SetSnowballActiveLocal(false);

GetProjectile("GrowingSnowballRightAnchor").SetSnowballActiveLocal(false);
}

public static void FastHoverboard()

 {
[Link] =
[Link];
[Link] =
5f;
[Link] = 0f;
[Link] = 1f;
}

public static void SlowHoverboard()

{
[Link] = 3.5f;
[Link] =
0.025f;
[Link] = 3f;
[Link] =
0.1f;
}

public static void FixHoverboard()

{
[Link] = 10f;
[Link] =
0.1f;
[Link] = 1f;
[Link] =
0.2f;
}

private static bool hasGrabbedHoverboard;

public static void GlobalHoverboard()
{
if (!hasGrabbedHoverboard)
{
[Link](false,
[Link], [Link], [Link]);
hasGrabbedHoverboard = true;
}

[Link](true);
[Link](true);
[Link](true);
}

public static void DisableGlobalHoverboard()

{
hasGrabbedHoverboard = false;

[Link](false);
[Link](false);
[Link](false);
}

public static void SpawnHoverboard()

{

[Link]([Link],
[Link], [Link], [Link], RandomColor());
[Link](true);
 }

private static float hoverboardSpamDelay;

public static void HoverboardSpam()
{
if (rightGrab && [Link] > hoverboardSpamDelay)
{
hoverboardSpamDelay = [Link] + 0.5f;

[Link]([Link]
[Link], [Link],
[Link] * ShootStrength,
RandomVector3(100f), RandomColor());
}
}

public static void OrbitHoverboards()

{
if ([Link] > hoverboardSpamDelay)
{
hoverboardSpamDelay = [Link] + 0.2f;

float offset = 0f;

Vector3 position = new Vector3([Link](offset +
((float)[Link] / 30)) * 2f, 1f, [Link](offset + ((float)[Link]
/ 30)) * 2f);

offset = -25f;
Vector3 position2 = new Vector3([Link](offset +
((float)[Link] / 30)) * 2f, 1f, [Link](offset + ((float)[Link]
/ 30)) * 2f);

[Link]([Link]
.[Link] + position,
[Link](([Link] -
position).normalized), (position2 - position).normalized * 6.5f, new Vector3(0f,
360f, 0f), RandomColor());

offset = 180f;
position = new Vector3([Link](offset + ((float)[Link] /
30)) * 2f, 1f, [Link](offset + ((float)[Link] / 30)) * 2f);

offset = 155f;
position2 = new Vector3([Link](offset +
((float)[Link] / 30)) * 2f, 1f, [Link](offset + ((float)[Link]
/ 30)) * 2f);

[Link]([Link]
.[Link] + position,
[Link](([Link] -
position).normalized), (position2 - position).normalized * 6.5f, new Vector3(0f,
360f, 0f), RandomColor());
}
}

public static void StartAllRaces()

 {
foreach ([Link] race in [Link])
{
if ([Link] == [Link])
race.Button_StartRace(5);
}
}

public static void RainbowHoverboard()

{
if ([Link] != null &&
[Link])
{
float h = ([Link] / 180f) % 1f;
Color rgbColor = [Link](h, 1f, 1f);

[Link]([Link]
ded, [Link],
[Link], rgbColor);
}
}

private static bool flashColor;

private static float flashDelay;
public static void StrobeHoverboard()
{
if ([Link] != null &&
[Link])
{
if ([Link] > flashDelay)
{
flashDelay = [Link] + 0.1f;
flashColor = !flashColor;
}

Color rgbColor = flashColor ? [Link] : [Link];

[Link]([Link]
ded, [Link],
[Link], rgbColor);
}
}

public static void RandomHoverboard()

{
if ([Link] != null &&
[Link])

[Link]([Link]
ded, [Link],
[Link], RandomColor());
}

public static void ModifyGliderSpeed(float pullUpLiftBonus, float

dragVsSpeedDragFactor)
{
foreach (GliderHoldable glider in GetAllType<GliderHoldable>())
{
[Link] = pullUpLiftBonus;
 [Link] = dragVsSpeedDragFactor;
}
}

public static void FixGliderSpeed()

{
foreach (GliderHoldable glider in GetAllType<GliderHoldable>())
{
[Link] = 0.1f;
[Link] = 0.2f;
}
}

public static void ObjectToHand(string objectName)

{
if (rightGrab)
[Link](objectName).[Link] =
[Link];
}

public static void GrabGliders()

{
if (rightGrab)
{
foreach (GliderHoldable glider in GetAllType<GliderHoldable>())
{
if ([Link] == [Link])
{
[Link] =
[Link];
}
else
{
[Link](null, null);
}
}
}
}

public static void SpamGrabBlocks()

{
if (rightGrab)
{
RequestCreatePiece(pieceIdSet,
[Link],
[Link], 0);
RPCProtection();
}
}

public static void DestroyObject(string objectName) =>

[Link](objectName).[Link] = new Vector3(99999f,
99999f, 99999f);

public static void RespawnGliders()

{
foreach (GliderHoldable glider in GetAllType<GliderHoldable>())
{
if ([Link] == [Link])
 {
[Link]();
}
else
{
[Link](null, null);
}
}
}

private static float delayer = -1f;

public static void DestroyBlocks()
{
if ([Link] > delayer)
{
delayer = [Link] + 1f;
ClearType<BuilderPiece>();
int count = 0;
foreach (BuilderPiece piece in GetAllType<BuilderPiece>())
{
if (count > 400)
break;
if ([Link])
{
count++;
GetBuilderTable().RequestRecyclePiece(piece, true, 2);
}
}
}
}

private static bool isFiring = false;

public static IEnumerator FireShotgun()
{
if (![Link])
{

[Link]("<color=grey>[</color><color=red>ERROR</
color><color=grey>]</color> <color=white>You are not master client.</color>");
yield break;
}

isFiring = true;

if (![Link]("iisStupidMenu/[Link]"))

LoadSoundFromURL("[Link]
[Link]", "[Link]");

[Link]("[Link]");

BuilderPiece bullet = null;

yield return CreateGetPiece(1925587737, piece =>

{
bullet = piece;
});
while (bullet == null)
{
 yield return null;
}

GetBuilderTable().RequestGrabPiece(bullet, true, [Link],

[Link]);
yield return null;
GetBuilderTable().RequestDropPiece(bullet, TrueRightHand().position +
TrueRightHand().forward * 0.65f + TrueRightHand().right * 0.03f +
TrueRightHand().up * 0.05f, TrueRightHand().rotation, TrueRightHand().forward *
19.9f, [Link]);
yield return null;
}

public static void UnlimitedBuilding()

{
[Link] =
[Link];
[Link] = true;
}

public static void DisableUnlimitedBuilding()

{
[Link] = 50;
[Link] = false;
}

public static void DestroyBlockGun()

{
if (GetGunInput(false))
{
var GunData = RenderGun();
RaycastHit Ray = [Link];
GameObject NewPointer = [Link];

if (GetGunInput(true))
{
BuilderPiece gunTarget =
[Link]<BuilderPiece>();
if (gunTarget)
{
GetBuilderTable().RequestRecyclePiece(gunTarget, true, 2);
RPCProtection();
}
}
}
//RPCProtection();
}

public static void RequestCreatePiece(int pieceType, Vector3 position,

Quaternion rotation, int materialType)
{
if ([Link])
{
int pieceId = GetBuilderTable().CreatePieceId();

GetBuilderTable().[Link]("PieceCreatedByShelfRPC",
[Link], new object[]
{
 pieceType,
pieceId,
[Link](position),
[Link](rotation),
materialType,
(byte)4,
1,
[Link]
});
} else

[Link]("<color=grey>[</color><color=red>ERROR</
color><color=grey>]</color> <color=white>You are not master client.</color>");
}

public static void BuildingBlockAura()

{
RequestCreatePiece(pieceIdSet, [Link] +
[Link](new Vector3([Link](-1f, 1f),
[Link](-1f, 1f), [Link](-1f, 1f))) * 2f,
[Link], 0);
RPCProtection();
}

public static void RainBuildingBlocks()

{
RequestCreatePiece(pieceIdSet, [Link] + new
Vector3([Link](-3f, 3f), 4f, [Link](-3f, 3f)),
[Link], 0);
RPCProtection();
}

public static void SpazObject(string objectName) =>

[Link](objectName).[Link] = [Link](new
Vector3([Link](0, 360), [Link](0, 360),
[Link](0, 360)));

public static void SpazGliders()

{
foreach (GliderHoldable glider in GetAllType<GliderHoldable>())
{
if ([Link] == [Link])
{
[Link] = [Link](new
Vector3([Link](0, 360), [Link](0, 360),
[Link](0, 360)));
}
else
{
[Link](null, null);
}
}
}

public static void OrbitObject(string objectName, float offset = 0) =>

[Link](objectName).[Link] =
[Link] + new
Vector3([Link](offset + ((float)[Link] / 30)), 2, [Link](offset +
((float)[Link] / 30)));
 public static void OrbitGliders()
{
GliderHoldable[] them = GetAllType<GliderHoldable>();
int index = 0;
foreach (GliderHoldable glider in them)
{
if ([Link] == [Link])
{
float offset = (360f / (float)[Link]) * index;
[Link] =
[Link] + new
Vector3([Link](offset + ((float)[Link] / 30)) * 5f, 2, [Link](offset
+ ((float)[Link] / 30)) * 5f);
}
else
{
[Link](null, null);
}
index++;
}
}

public static void OrbitBlocks()

{
RequestCreatePiece(pieceIdSet,
[Link] + new
Vector3([Link]((float)[Link] / 30), 0f,
[Link]((float)[Link] / 30)), [Link], 0);
RPCProtection();
}

public static void RideObject(string objectName)

{
TeleportPlayer([Link](objectName).[Link]);
[Link] = [Link];
}

public static void AllowStealingThrowableBug(string objectName, bool

allowPlayerStealing) =>

[Link](objectName).GetComponent<ThrowableBug>().allowPlayerStealing =
allowPlayerStealing;

public static void MultiGrab()

{
[Link][1] =
[Link];
[Link][1] = null;
}

public static int pieceId = -1;

public static IEnumerator CreateGetPiece(int pieceType,
Action<BuilderPiece> onComplete)
{
BuilderPiece target = null;

[Link] = true;
[Link] = pieceType;
 yield return null;

RequestCreatePiece(pieceType, [Link] + new

Vector3(0f, 1f, 0f), [Link], 0);
RPCProtection();

while (pieceId < 0)

{
yield return null;
}
yield return null;

target = GetBuilderTable().GetPiece(pieceId);
pieceId = -1;
[Link] = false;
[Link] = 0;

onComplete?.Invoke(target); // so bad
}

public static IEnumerator CreateShotgun()

{
if (![Link])
{

[Link]("<color=grey>[</color><color=red>ERROR</
color><color=grey>]</color> <color=white>You are not master client.</color>");
yield break;
}

BuilderPiece basea = null;

yield return CreateGetPiece(-1927069002, piece =>

{
basea = piece;
});
while (basea == null)
{
yield return null;
}

GetBuilderTable().RequestGrabPiece(basea, false, [Link],

[Link]);
yield return null;

[Link][1] =
[Link];
[Link][1] = null;
yield return null;

BuilderPiece base2a = null;

yield return CreateGetPiece(-1621444201, piece =>

{
base2a = piece;

});
while (base2a == null)
 {
yield return null;
}

GetBuilderTable().RequestGrabPiece(base2a, false, [Link],

[Link]);
yield return null;
GetBuilderTable().RequestPlacePiece(base2a, base2a, 0, 0, 0, basea, 1,
0);
yield return null;

BuilderPiece slopea = null;

yield return CreateGetPiece(-993249117, piece =>

{
slopea = piece;

});
while (slopea == null)
{
yield return null;
}

GetBuilderTable().RequestGrabPiece(slopea, false, [Link],

[Link]);
yield return null;
GetBuilderTable().RequestPlacePiece(slopea, slopea, 0, 0, 2, base2a, 1,
0);
yield return null;

BuilderPiece trigger = null;

yield return CreateGetPiece(251444537, piece =>

{
trigger = piece;
});
while (trigger == null)
{
yield return null;
}

GetBuilderTable().RequestGrabPiece(trigger, false, [Link],

[Link]);
yield return null;
GetBuilderTable().RequestPlacePiece(trigger, trigger, -1, -2, 3,
slopea, 1, 0);
yield return null;

BuilderPiece slopeb = null;

yield return CreateGetPiece(-993249117, piece =>

{
slopeb = piece;
});
while (slopeb == null)
{
yield return null;
}
 GetBuilderTable().RequestGrabPiece(slopeb, false, [Link],
[Link]);
yield return null;
GetBuilderTable().RequestPlacePiece(basea, trigger, 0, -2, 3, slopeb,
1, 0);
yield return null;

BuilderPiece base2b = null;

yield return CreateGetPiece(-1621444201, piece =>

{
base2b = piece;
});
while (base2b == null)
{
yield return null;
}

GetBuilderTable().RequestGrabPiece(base2b, false, [Link],

[Link]);
yield return null;
GetBuilderTable().RequestPlacePiece(slopeb, slopeb, 0, 0, 2, base2b, 1,
0);
yield return null;

BuilderPiece baseb = null;

yield return CreateGetPiece(-1927069002, piece =>

{
baseb = piece;
});
while (baseb == null)
{
yield return null;
}

GetBuilderTable().RequestGrabPiece(baseb, false, [Link],

[Link]);
yield return null;
GetBuilderTable().RequestPlacePiece(base2b, base2b, 0, 0, 0, baseb, 1,
0);
yield return null;

BuilderPiece minislopeb = null;

yield return CreateGetPiece(1700655257, piece =>

{
minislopeb = piece;
});
while (minislopeb == null)
{
yield return null;
}

GetBuilderTable().RequestGrabPiece(minislopeb, false, [Link],

[Link]);
yield return null;
GetBuilderTable().RequestPlacePiece(baseb, slopea, 0, -3, 2,
minislopeb, 2, 0);
 yield return null;

BuilderPiece minislopea = null;

yield return CreateGetPiece(1700655257, piece =>

{
minislopea = piece;
});
while (minislopea == null)
{
yield return null;
}

GetBuilderTable().RequestGrabPiece(minislopea, false, [Link],

[Link]);
yield return null;
GetBuilderTable().RequestPlacePiece(minislopeb, slopeb, 0, -3, 2,
minislopea, 2, 0);
yield return null;

BuilderPiece minislope2a = null;

yield return CreateGetPiece(1700655257, piece =>

{
minislope2a = piece;
});
while (minislope2a == null)
{
yield return null;
}

GetBuilderTable().RequestGrabPiece(minislope2a, false, [Link],

[Link]);
yield return null;
GetBuilderTable().RequestPlacePiece(minislopea, minislopeb, 0, 0, 2,
minislope2a, 1, 0);
yield return null;

BuilderPiece minislope2b = null;

yield return CreateGetPiece(1700655257, piece =>

{
minislope2b = piece;
});
while (minislope2b == null)
{
yield return null;
}

GetBuilderTable().RequestGrabPiece(minislope2b, false, [Link],

[Link]);
yield return null;
GetBuilderTable().RequestPlacePiece(minislope2a, minislopea, 0, 0, 2,
minislope2b, 1, 0);
yield return null;

BuilderPiece flatthinga = null;

yield return CreateGetPiece(477262573, piece =>

 {
flatthinga = piece;
});
while (flatthinga == null)
{
yield return null;
}

GetBuilderTable().RequestGrabPiece(flatthinga, false, [Link],

[Link]);
yield return null;
GetBuilderTable().RequestPlacePiece(minislope2b, minislope2b, 0, -1, 2,
flatthinga, 2, 0);
yield return null;

BuilderPiece flatthingb = null;

yield return CreateGetPiece(477262573, piece =>

{
flatthingb = piece;
});
while (flatthingb == null)
{
yield return null;
}

GetBuilderTable().RequestGrabPiece(flatthingb, false, [Link],

[Link]);
yield return null;
GetBuilderTable().RequestPlacePiece(flatthinga, minislope2a, 0, -1, 2,
flatthingb, 2, 0);
yield return null;

BuilderPiece connectorthinga = null;

yield return CreateGetPiece(251444537, piece =>

{
connectorthinga = piece;
});
while (connectorthinga == null)
{
yield return null;
}

GetBuilderTable().RequestGrabPiece(connectorthinga, false,
[Link], [Link]);
yield return null;
GetBuilderTable().RequestPlacePiece(flatthingb, flatthinga, -1, 1, 3,
connectorthinga, 1, 0);
yield return null;

BuilderPiece connectorthingb = null;

yield return CreateGetPiece(661312857, piece =>

{
connectorthingb = piece;
});
while (connectorthingb == null)
{
 yield return null;
}

GetBuilderTable().RequestGrabPiece(connectorthingb, false,
[Link], [Link]);
yield return null;
GetBuilderTable().RequestPlacePiece(connectorthinga, connectorthinga, -
1, 0, 1, connectorthingb, 1, 0);
yield return null;

BuilderPiece connectorthingc = null;

yield return CreateGetPiece(661312857, piece =>

{
connectorthingc = piece;
});
while (connectorthingc == null)
{
yield return null;
}

GetBuilderTable().RequestGrabPiece(connectorthingc, false,
[Link], [Link]);
yield return null;
GetBuilderTable().RequestPlacePiece(connectorthingb, connectorthinga,
0, 0, 1, connectorthingc, 1, 0);
yield return null;

BuilderPiece barrela = null;

yield return CreateGetPiece(661312857, piece =>

{
barrela = piece;
});
while (barrela == null)
{
yield return null;
}

GetBuilderTable().RequestGrabPiece(barrela, false, [Link],

[Link]);
yield return null;
GetBuilderTable().RequestPlacePiece(connectorthingc, connectorthingb,
0, 0, 1, barrela, 1, 0);
yield return null;

BuilderPiece barrelb = null;

yield return CreateGetPiece(661312857, piece =>

{
barrelb = piece;
});
while (barrelb == null)
{
yield return null;
}

GetBuilderTable().RequestGrabPiece(barrelb, false, [Link],

[Link]);
 yield return null;
GetBuilderTable().RequestPlacePiece(barrela, barrela, 0, 0, 2, barrelb,
1, 0);
yield return null;

BuilderPiece scope = null;

yield return CreateGetPiece(-648273975, piece =>

{
scope = piece;
});
while (scope == null)
{
yield return null;
}

GetBuilderTable().RequestGrabPiece(scope, false, [Link],

[Link]);
yield return null;
GetBuilderTable().RequestPlacePiece(barrelb, minislope2a, -2, 1, 3,
scope, 1, 0);
yield return null;
GetBuilderTable().RequestDropPiece(scope,
[Link], [Link],
[Link], [Link]);
yield return null;
// pos is forward/back, left/right, up/down
GetBuilderTable().RequestGrabPiece(basea, false, new Vector3(-0.2f,
0.01f, -0.3f), new Quaternion(0f, 0.1f, 0.75f, -0.6f));
yield return null;
}

private static bool lastgripcrap;

private static bool lasttrigcrap;
public static void Shotgun()
{
if (isFiring)
[Link] = 1f;

if (rightGrab && !lastgripcrap)

[Link](CreateShotgun());

if (rightGrab && (rightTrigger > 0.5f && !lasttrigcrap))

[Link](FireShotgun());

lastgripcrap = rightGrab;
lasttrigcrap = rightTrigger > 0.5f;
}

public static IEnumerator CreateMassiveBlock()

{
[Link] = 2;
yield return new WaitForSeconds(0.55f);

BuilderPiece stupid = null;

yield return CreateGetPiece(pieceIdSet, piece =>

{
stupid = piece;
 });
while (stupid == null)
{
yield return null;
}

GetBuilderTable().RequestGrabPiece(stupid, false, [Link],

[Link]);
yield return new WaitForSeconds(0.7f);

[Link] = 13;
}

public static void MassiveBlock()

{
if (rightGrab && !lastgripcrap)
[Link](CreateMassiveBlock());

lastgripcrap = rightGrab;
}

public static void AtticSizeToggle()

{
if (rightTrigger > 0.5f)
[Link] = 13;

if (rightGrab)
[Link] = 2;
}

public static void SlowMonsters()

{
foreach (MonkeyeAI monkeyeAI in GetAllType<MonkeyeAI>())
{
if (![Link])
{ [Link]("<color=grey>[</color><color=red>ERROR</
color><color=grey>]</color> <color=white>You are not master client.</color>");
return; }
[Link] = 0.02f;
}
}

public static void FastMonsters()

{
foreach (MonkeyeAI monkeyeAI in GetAllType<MonkeyeAI>())
{
if (![Link])
{ [Link]("<color=grey>[</color><color=red>ERROR</
color><color=grey>]</color> <color=white>You are not master client.</color>");
return; }
[Link] = 0.5f;
}
}

public static void FixMonsters()

{
foreach (MonkeyeAI monkeyeAI in GetAllType<MonkeyeAI>())
{
if (![Link])
{ [Link]("<color=grey>[</color><color=red>ERROR</
color><color=grey>]</color> <color=white>You are not master client.</color>");
return; }
[Link] = 0.1f;
}
}

public static void GrabMonsters()

{
if (rightGrab)
{
foreach (MonkeyeAI monkeyeAI in GetAllType<MonkeyeAI>())
{
if (![Link])
{ [Link]("<color=grey>[</color><color=red>ERROR</
color><color=grey>]</color> <color=white>You are not master client.</color>");
return; }
[Link] =
[Link];
}
}
}

public static void MonsterGun()

{
if (GetGunInput(false))
{
var GunData = RenderGun();
RaycastHit Ray = [Link];
GameObject NewPointer = [Link];

if (GetGunInput(true))
{
foreach (MonkeyeAI monkeyeAI in GetAllType<MonkeyeAI>())
{
if (![Link])
{ [Link]("<color=grey>[</color><color=red>ERROR</
color><color=grey>]</color> <color=white>You are not master client.</color>");
return; }
[Link] =
[Link] + new Vector3(0f, 1f, 0f);
}
}
}
}

public static void SpazMonsters()

{
foreach (MonkeyeAI monkeyeAI in GetAllType<MonkeyeAI>())
{
if (![Link])
{ [Link]("<color=grey>[</color><color=red>ERROR</
color><color=grey>]</color> <color=white>You are not master client.</color>");
return; }
[Link] = [Link](new
Vector3([Link](0, 360), [Link](0, 360),
[Link](0, 360)));
}
}
 public static void OrbitMonsters()
{
MonkeyeAI[] them = GetAllType<MonkeyeAI>();
int index = 0;
foreach (MonkeyeAI monkeyeAI in GetAllType<MonkeyeAI>())
{
if (![Link])
{ [Link]("<color=grey>[</color><color=red>ERROR</
color><color=grey>]</color> <color=white>You are not master client.</color>");
return; }
float offset = (360f / (float)[Link]) * index;
[Link] =
[Link] + new
Vector3([Link](offset + ((float)[Link] / 30)) * 2f, 1f,
[Link](offset + ((float)[Link] / 30)) * 2f);
index++;
}
}

public static void DestroyMonsters()

{
foreach (MonkeyeAI monkeyeAI in GetAllType<MonkeyeAI>())
{
if (![Link])
{ [Link]("<color=grey>[</color><color=red>ERROR</
color><color=grey>]</color> <color=white>You are not master client.</color>");
return; }
[Link] = new Vector3(99999f,
99999f, 99999f);
}
}

public static List<BuilderPiece> GetBlocks(string blockname)

{
List<BuilderPiece> blocks = new List<BuilderPiece> { };

foreach (BuilderPiece filteredBlock in GetPiecesFiltered())

{
if ([Link]().Contains(blockname))
[Link](filteredBlock);
}

return blocks;
}

private static List<BuilderPiece> potentialgrabbedpieces = new

List<BuilderPiece> { };
public static void GrabAllBlocksNearby()
{
if (rightGrab && [Link] > blockDelay)
{
blockDelay = [Link] + 0.25f;
int amnt = 0;
foreach (BuilderPiece piece in GetAllType<BuilderPiece>())
{
if ([Link]([Link],
[Link]) < 2.5f)
{
 if ()
{
amnt++;
if (amnt < 8)
{
GetBuilderTable().RequestGrabPiece(piece, false,
new Vector3([Link](-0.5f, 0.5f), [Link](-0.5f,
0.5f), [Link](-0.5f, 0.5f)), [Link]);
[Link](piece);
}
}
}
}
RPCProtection();
}
if (rightTrigger > 0.5f && [Link] > blockDelay)
{
blockDelay = [Link] + 0.25f;
foreach (BuilderPiece piece in potentialgrabbedpieces)
GetBuilderTable().RequestDropPiece(piece,
[Link],
[Link], new
Vector3([Link](-19f, 19f), [Link](-19f, 19f),
[Link](-19f, 19f)), new Vector3([Link](-19f,
19f), [Link](-19f, 19f), [Link](-19f, 19f)));

[Link]();
RPCProtection();
}
}

public static void PopAllBalloons()

{
foreach (BalloonHoldable balloon in GetAllType<BalloonHoldable>())
[Link]();
}

public static void GrabBalloons()

{
if (rightGrab)
{
foreach (BalloonHoldable balloon in GetAllType<BalloonHoldable>())
{
if ([Link] == [Link])
[Link] =
[Link];
else
[Link]();
}
}
}

public static void SpazBalloons()

{
foreach (BalloonHoldable balloon in GetAllType<BalloonHoldable>())
{
if ([Link] == [Link])
[Link] = [Link](new
Vector3([Link](0, 360), [Link](0, 360),
[Link](0, 360)));
else
[Link]();
}
}

public static void OrbitBalloons()

{
BalloonHoldable[] them = GetAllType<BalloonHoldable>();
int index = 0;
foreach (BalloonHoldable balloon in them)
{
if ([Link] == [Link])
{
float offset = (360f / [Link]) * index;
[Link] =
[Link] + new
Vector3([Link](offset + ((float)[Link] / 30)) * 5f, 2, [Link](offset
+ ((float)[Link] / 30)) * 5f);
}
else
[Link]();

index++;
}
}

public static void BalloonGun()

{
if (GetGunInput(false))
{
var GunData = RenderGun();
RaycastHit Ray = [Link];
GameObject NewPointer = [Link];

if (GetGunInput(true))
{
foreach (BalloonHoldable balloon in
GetAllType<BalloonHoldable>())
{
if ([Link] == [Link])
[Link] =
[Link] + new Vector3(0f, 1f, 0f);
else
[Link]();
}
}
}
}

public static void DestroyBalloons()

{
foreach (BalloonHoldable balloon in GetAllType<BalloonHoldable>())
{
if ([Link] == [Link])
[Link] = new Vector3(99999f,
99999f, 99999f);
else
[Link]();
 }
}

// I would like to apologize to anyone who had this beforehand

// "Tubski" will be long loved forever because that was the original name
of this mod I don't know what that means
public static void BecomeBalloon()
{
if (rightTrigger > 0.5f)
{
[Link] = false;
[Link] = true;
[Link] = new Vector3(-51.4897f,
16.9286f, -120.1083f);

bool FoundBalloon = false;

foreach (BalloonHoldable Balloon in GetAllType<BalloonHoldable>())
{
if ([Link] == [Link] &&
[Link]("LMAMI"))
{
FoundBalloon = true;

[Link] = [Link];
[Link] =
[Link];

[Link] =
[Link] +
([Link] * - 1f);
[Link] =
[Link];
}
}

if (!FoundBalloon)
{

[Link]([Link],
[Link]("LMAAP."), true, false);
[Link](true);
RPCProtection();

ClearType<BalloonHoldable>();
}
}
else
{
if (![Link])
[Link] = true;
}
}

public static void DestroyGliders()

{
foreach (GliderHoldable glider in GetAllType<GliderHoldable>())
{
if ([Link] == [Link])
[Link] = new Vector3(99999f,
99999f, 99999f);
else
[Link](null, null);
}
}

public static float nameCycleDelay;

public static int nameCycleIndex;
public static void NameCycle(string[] names)
{
if ([Link] > nameCycleDelay)
{
nameCycleIndex++;
if (nameCycleIndex > [Link] - 1)
nameCycleIndex = 0;

ChangeName(names[nameCycleIndex]);
nameCycleDelay = [Link] + 1f;
}
}

public static void RandomNameCycle() =>

NameCycle(new string[] { GenerateRandomString(8) });

public static string[] names = new string[] { };

public static void EnableCustomNameCycle()
{
if ([Link]("iisStupidMenu/iiMenu_CustomNameCycle.txt"))
names =
[Link]("iisStupidMenu/iiMenu_CustomNameCycle.txt").Split('\n');
else
[Link]("iisStupidMenu/iiMenu_CustomNameCycle.txt","YOUR\
nTEXT\nHERE");
}

public static void StrobeColor()

{
if ([Link] > colorChangerDelay)
{
colorChangerDelay = [Link] + 0.1f;
strobeColor = !strobeColor;
ChangeColor(new Color(strobeColor ? 1 : 0, strobeColor ? 1 : 0,
strobeColor ? 1 : 0));
}
}

public static void RainbowColor()

{
if ([Link] > colorChangerDelay)
{
colorChangerDelay = [Link] + 0.1f;
float h = ([Link] / 180f) % 1f;
ChangeColor([Link](h, 1f, 1f));
}
}

public static void HardRainbowColor()

{
if ([Link] > colorChangerDelay)
 {
colorChangerDelay = [Link] + 1f;
colorChangeType++;
if (colorChangeType > 3)
colorChangeType = 0;

Color[] colors = new Color[]

{
[Link],
[Link],
[Link],
[Link]
};

ChangeColor(colors[colorChangeType]);
}
}

public static void BecomePlayer(string name, Color color)

{
ChangeName(name);
ChangeColor(color);
}

public static void BecomeMinigamesKid()

{
string[] names = new string[]
{
"MINIGAMES",
"MINIGAMESKID",
"LITTLETIMMY",
"TIMMY",
"SILLYBILLY"
};
Color[] colors = new Color[]
{
[Link],
[Link],
[Link],
[Link]
};

BecomePlayer(names[[Link](0, [Link] - 1)],

colors[[Link](0, [Link] - 1)]);
}

public static void CopyIdentityGun()

{
if (GetGunInput(false))
{
var GunData = RenderGun();
RaycastHit Ray = [Link];
GameObject NewPointer = [Link];

if (GetGunInput(true) && [Link] > stealIdentityDelay)

{
VRRig gunTarget = [Link]<VRRig>();
if (gunTarget && !PlayerIsLocal(gunTarget))
{
 ChangeName(GetPlayerFromVRRig(gunTarget).NickName);
ChangeColor([Link]);
stealIdentityDelay = [Link] + 0.5f;
}
}
}
}

public static int accessoryType;

public static int hat;
public static void ChangeAccessories()
{
if (leftGrab && !lastHitL)
{
hat--;
if (hat < 1)
hat = 3;

switch (hat)
{
case 1:
[Link]("Environment
Objects/LocalObjects_Prefab/TreeRoom/TreeRoomInteractables/UI/Wardrobe/
WardrobeItemButton")
.GetComponent<GorillaPressableButton>().ButtonActivatio
nWithHand(false);
break;
case 2:
[Link]("Environment
Objects/LocalObjects_Prefab/TreeRoom/TreeRoomInteractables/UI/Wardrobe/
WardrobeItemButton (1)")
.GetComponent<GorillaPressableButton>().ButtonActivatio
nWithHand(false);
break;
case 3:
[Link]("Environment
Objects/LocalObjects_Prefab/TreeRoom/TreeRoomInteractables/UI/Wardrobe/
WardrobeItemButton (2)")
.GetComponent<GorillaPressableButton>().ButtonActivatio
nWithHand(false);
break;
}
}
lastHitL = leftGrab;
if (rightGrab && !lastHitR)
{
hat++;
if (hat > 3)
hat = 1;

switch (hat)
{
case 1:
[Link]("Environment
Objects/LocalObjects_Prefab/TreeRoom/TreeRoomInteractables/UI/Wardrobe/
WardrobeItemButton").GetComponent<GorillaPressableButton>().ButtonActivationWithHan
d(false);
break;
case 2:
 [Link]("Environment
Objects/LocalObjects_Prefab/TreeRoom/TreeRoomInteractables/UI/Wardrobe/
WardrobeItemButton
(1)").GetComponent<GorillaPressableButton>().ButtonActivationWithHand(false);
break;
case 3:
[Link]("Environment
Objects/LocalObjects_Prefab/TreeRoom/TreeRoomInteractables/UI/Wardrobe/
WardrobeItemButton
(2)").GetComponent<GorillaPressableButton>().ButtonActivationWithHand(false);
break;
}

}
lastHitR = rightGrab;
if (leftPrimary && !lastHitLP)
{
[Link]("Environment
Objects/LocalObjects_Prefab/TreeRoom/TreeRoomInteractables/UI/Wardrobe/
WardrobeLeftButton").GetComponent<WardrobeFunctionButton>().ButtonActivation();
switch (hat)
{
case 1:
[Link]("Environment
Objects/LocalObjects_Prefab/TreeRoom/TreeRoomInteractables/UI/Wardrobe/
WardrobeItemButton").GetComponent<GorillaPressableButton>().ButtonActivationWithHan
d(false);
break;
case 2:
[Link]("Environment
Objects/LocalObjects_Prefab/TreeRoom/TreeRoomInteractables/UI/Wardrobe/
WardrobeItemButton
(1)").GetComponent<GorillaPressableButton>().ButtonActivationWithHand(false);
break;
case 3:
[Link]("Environment
Objects/LocalObjects_Prefab/TreeRoom/TreeRoomInteractables/UI/Wardrobe/
WardrobeItemButton
(2)").GetComponent<GorillaPressableButton>().ButtonActivationWithHand(false);
break;
}
}
lastHitLP = leftPrimary;

if (rightPrimary && !lastHitRP)

{
[Link]("Environment
Objects/LocalObjects_Prefab/TreeRoom/TreeRoomInteractables/UI/Wardrobe/
WardrobeRightItem").GetComponent<WardrobeFunctionButton>().ButtonActivation();
switch (hat)
{
case 1:
[Link]("Environment
Objects/LocalObjects_Prefab/TreeRoom/TreeRoomInteractables/UI/Wardrobe/
WardrobeItemButton").GetComponent<GorillaPressableButton>().ButtonActivationWithHan
d(false);
break;
case 2:
[Link]("Environment
Objects/LocalObjects_Prefab/TreeRoom/TreeRoomInteractables/UI/Wardrobe/
WardrobeItemButton
(1)").GetComponent<GorillaPressableButton>().ButtonActivationWithHand(false);
break;
case 3:
[Link]("Environment
Objects/LocalObjects_Prefab/TreeRoom/TreeRoomInteractables/UI/Wardrobe/
WardrobeItemButton
(2)").GetComponent<GorillaPressableButton>().ButtonActivationWithHand(false);
break;
}
}
lastHitRP = rightPrimary;

if (rightSecondary && !lastHitRS)

{
accessoryType++;
if (accessoryType > 4)
accessoryType = 1;

switch (accessoryType)
{
case 1:
[Link]("Environment
Objects/LocalObjects_Prefab/TreeRoom/TreeRoomInteractables/UI/Wardrobe/
WardobeHatButton").GetComponent<WardrobeFunctionButton>().ButtonActivation();
break;
case 2:
[Link]("Environment
Objects/LocalObjects_Prefab/TreeRoom/TreeRoomInteractables/UI/Wardrobe/
WardrobeFaceButton").GetComponent<WardrobeFunctionButton>().ButtonActivation();
break;
case 3:
[Link]("Environment
Objects/LocalObjects_Prefab/TreeRoom/TreeRoomInteractables/UI/Wardrobe/
WardrobeBadgeButton").GetComponent<WardrobeFunctionButton>().ButtonActivation();
break;
case 4:
[Link]("Environment
Objects/LocalObjects_Prefab/TreeRoom/TreeRoomInteractables/UI/Wardrobe/
WardrobeHoldableButton").GetComponent<WardrobeFunctionButton>().ButtonActivation();
break;
}
}
lastHitRS = rightSecondary;
}

private static Dictionary<string[], int[]> cachePacked = new

Dictionary<string[], int[]> { };
public static int[] PackCosmetics(string[] Cosmetics)
{
if ([Link](Cosmetics))
return cachePacked[Cosmetics];

[Link] Set = new

[Link](Cosmetics, [Link]);
int[] PackedIDs = [Link]();
[Link](Cosmetics, PackedIDs);
return PackedIDs;
 }

private static List<string> ownedarchive = null;

private static string[] GetOwnedCosmetics()
{
if (ownedarchive == null)
{
ownedarchive = new List<string> { };
foreach ([Link] dearlord in
[Link])
{
if
([Link]([Link]))
{
[Link]([Link]);
}
}
}
return [Link]();
}
private static List<string> tryonarchive = null;
private static string[] GetTryOnCosmetics()
{
if (tryonarchive == null)
{
tryonarchive = new List<string> { };
foreach ([Link] dearlord in
[Link])
{
if ([Link])
[Link]([Link]);
}
}
return [Link]();
}

private static float delay = 0f;

public static void SpazAccessories()
{
if (rightTrigger > 0.5f && [Link] > delay)
{
delay = [Link] + 0.05f;
string[] owned = [Link] ? GetTryOnCosmetics() :
GetOwnedCosmetics();
int amnt = [Link]([Link], 0, 15);
if (amnt > 0)
{
List<string> holyshit = new List<string> { };
for (int i = 0; i <= amnt; i++)
[Link](owned[[Link](0, [Link]
- 1)]);

if ([Link])
{
[Link] = new
[Link]([Link](), [Link]);
[Link] = new
[Link]([Link](), [Link]);
}
 else
{
[Link] = new
[Link]([Link](), [Link]);
[Link] = new
[Link]([Link](), [Link]);
}

[Link]("RPC_UpdateCosmeticsWithTryonPacked",
[Link], new object[] { PackCosmetics([Link]()),
PackCosmetics([Link]()) });
RPCProtection();
}
}
}

public static void SpazAccessoriesOthers()

{
if (rightTrigger > 0.5f && [Link] > delay)
{
delay = [Link] + 0.05f;
string[] owned = [Link] ? GetTryOnCosmetics() :
GetOwnedCosmetics();
int amnt = [Link]([Link], 0, 15);
if (amnt > 0)
{
List<string> holyshit = new List<string> { };
for (int i = 0; i <= amnt; i++)
[Link](owned[[Link](0, [Link]
- 1)]);
if ([Link])
{
[Link] = new
[Link]([Link](), [Link]);
[Link] = new
[Link]([Link](), [Link]);
}
else
{
[Link] = new
[Link]([Link](), [Link]);
[Link] = new
[Link]([Link](), [Link]);
}

[Link]("RPC_UpdateCosmeticsWithTryonPacked",
[Link], new object[] { PackCosmetics([Link]()),
PackCosmetics([Link]()) });
RPCProtection();
}
}
}

private static float delayonhold = 0f;

public static void StickyHoldables()
{
if ([Link] > delayonhold)
{
delayonhold = [Link] + 0.1f;
 foreach (TransferrableObject cosmet in
GetAllType<TransferrableObject>())
{
if ([Link]())
{
if ([Link] ==
[Link] || [Link] ==
[Link])
[Link] =
[Link];
if ([Link] ==
[Link] || [Link] ==
[Link] || [Link] ==
[Link])
[Link] =
[Link];
}
}
}
}

public static void SpazHoldables()

{
if ([Link] > delayonhold)
{
delayonhold = [Link] + 0.1f;
foreach (TransferrableObject cosmet in
GetAllType<TransferrableObject>())
{
if ([Link]())
{
[Link] = ([Link])
((int)[Link] * 2);
if ((int)[Link] > 128)
[Link] =
[Link];
}
}
}
}

private static int[] archiveCosmetics = null;

public static void TryOnAnywhere()
{
archiveCosmetics =
[Link]();
[Link] = new
[Link]([Link]<string>(),
[Link]);
[Link] = new
[Link]([Link]<string>(),
[Link]);

[Link]("RPC_UpdateCosmeticsWithTryonPacked",
[Link], new object[] { PackCosmetics([Link]<string>()),
[Link]() });
RPCProtection();
}
 public static void TryOffAnywhere()
{
[Link] = new
[Link](archiveCosmetics, [Link]);
[Link] = new
[Link](archiveCosmetics, [Link]);
[Link]("RPC_UpdateCosmeticsWithTryon",
[Link], new object[] { archiveCosmetics,
[Link]() });
RPCProtection();
}

public static void AddCosmeticToCart(string cosmetic)

{
[Link](0,
[Link](cosmetic));
[Link]();
}

private static int rememberdirectory = 0;

public static void CosmeticBrowser()
{
rememberdirectory = pageNumber;
currentCategoryName = "Temporary Category";

List<ButtonInfo> cosmeticbuttons = new List<ButtonInfo> { new

ButtonInfo { buttonText = "Exit Cosmetic Browser", method = () =>
RemoveCosmeticBrowser(), isTogglable = false, toolTip = "Returns you back to the
fun mods." } };
foreach ([Link] hat in
[Link])
{
if ([Link])
[Link](new ButtonInfo { buttonText =
ToTitleCase([Link]), method = () =>
AddCosmeticToCart([Link]), isTogglable = false, toolTip = "Adds the " +
[Link]() + "to your cart." });
}
[Link][29] = [Link]();
}

public static void RemoveCosmeticBrowser()

{
currentCategoryName = "Fun Mods";
pageNumber = rememberdirectory;
}

public static void AutoLoadCosmetics()

{
[Link] = true;
[Link] ??=
[Link]([Link]());
[Link]("Environment
Objects/TriggerZones_Prefab/ZoneTransitions_Prefab/Cosmetics Room
Triggers/TryOnRoom").GetComponent<CosmeticBoundaryTrigger>().enabled = false;
}

public static void NoAutoLoadCosmetics()

{
 [Link]("Environment
Objects/TriggerZones_Prefab/ZoneTransitions_Prefab/Cosmetics Room
Triggers/TryOnRoom").GetComponent<CosmeticBoundaryTrigger>().enabled = true;
[Link] = false;
}

private static float lastTimeCosmeticsChecked;

public static void AutoPurchaseCosmetics()
{
if (![Link])
lastTimeCosmeticsChecked = [Link] + 60f;

if ([Link] > lastTimeCosmeticsChecked)

{
lastTimeCosmeticsChecked = [Link] + 60f;
foreach ([Link] hat in
[Link])
{
if ([Link] == 0 && [Link] && !
[Link]([Link]))
{
[Link](new PurchaseItemRequest
{
ItemId = [Link],
Price = [Link],
VirtualCurrency =
[Link],
CatalogVersion = [Link]
}, delegate (PurchaseItemResult result)
{

[Link]("<color=grey>[</color><color=green>SUCCESS</
color><color=grey>]</color> Item \"" + ToTitleCase([Link]) + "\"
has been purchased.");

[Link]([Link], false, false);

}, null, null, null);
}
}
}
}

private static bool lasttagged = false;

public static void DisableCosmeticsOnTag()
{
if (!lasttagged && PlayerIsTagged([Link]))
{

[Link]("RPC_UpdateCosmeticsWithTryon",
[Link], new object[] { new string[] { "null", "null", "null", "null",
"null", "null", "null", "null", "null", "null", "null", "null", "null", "null",
"null", "null" }, new string[] { "null", "null", "null", "null", "null", "null",
"null", "null", "null", "null", "null", "null", "null", "null", "null",
"null" } });
RPCProtection();
}
if (lasttagged && !PlayerIsTagged([Link]))
{
[Link]("RPC_UpdateCosmeticsWithTryon",
[Link], new object[]
{ [Link](),
[Link]() });
RPCProtection();
}
lasttagged = PlayerIsTagged([Link]);
}

private static float idgundelay = 0f;

public static void CopyIDGun()
{
if (GetGunInput(false))
{
var GunData = RenderGun();
RaycastHit Ray = [Link];
GameObject NewPointer = [Link];

if (GetGunInput(true) && [Link] > idgundelay)

{
VRRig gunTarget = [Link]<VRRig>();
if (gunTarget && !PlayerIsLocal(gunTarget))
{
idgundelay = [Link] + 0.5f;
string id = GetPlayerFromVRRig(gunTarget).UserId;

[Link]("<color=grey>[</color><color=green>SUCCESS</
color><color=grey>]</color> " + id, 5000);
[Link] = id;
}
}
}
}

public static void CopySelfID()

{
string id = [Link];

[Link]("<color=grey>[</color><color=green>SUCCESS</
color><color=grey>]</color> " + id, 5000);
[Link] = id;
}

public static void NarrateIDGun()

{
if (GetGunInput(false))
{
var GunData = RenderGun();
RaycastHit Ray = [Link];
GameObject NewPointer = [Link];

if (GetGunInput(true) && [Link] > idgundelay)

{
VRRig gunTarget = [Link]<VRRig>();
if (gunTarget && !PlayerIsLocal(gunTarget))
{
idgundelay = [Link] + 0.5f;
[Link](SpeakText("Name: " +
GetPlayerFromVRRig(gunTarget).NickName + ". I D: " + [Link](" ",
GetPlayerFromVRRig(gunTarget).UserId)));
}
}
}
}

public static void NarrateSelfID() =>

[Link](SpeakText("Name: " +
[Link] + ". I D: " + [Link](" ",
[Link])));

private static float cgdgd = 0f;

public static void CopyCreationDateGun()
{
if (GetGunInput(false))
{
var GunData = RenderGun();
RaycastHit Ray = [Link];
GameObject NewPointer = [Link];

if (GetGunInput(true))
{
VRRig gunTarget = [Link]<VRRig>();
if (gunTarget && !PlayerIsLocal(gunTarget) && [Link] >
cgdgd)
{
cgdgd = [Link] + 0.5f;
[Link](new GetAccountInfoRequest {
PlayFabId = GetPlayerFromVRRig(gunTarget).UserId }, delegate (GetAccountInfoResult
result) // Who designed this
{
string date = [Link]("MMMM
dd, yyyy h:mm tt");

[Link]("<color=grey>[</color><color=green>SUCCESS</
color><color=grey>]</color> " + date, 5000);
[Link] = date;
}, delegate {
[Link]("<color=grey>[</color><color=red>ERROR</
color><color=grey>]</color> Could not copy creation date."); }, null, null);
}
}
}
}

public static void CopyCreationDateSelf()

{
[Link](new GetAccountInfoRequest { PlayFabId =
[Link] }, delegate (GetAccountInfoResult result) // Who
designed this
{
string date = [Link]("MMMM dd, yyyy
h:mm tt");

[Link]("<color=grey>[</color><color=green>SUCCESS</
color><color=grey>]</color> " + date, 5000);
[Link] = date;
}, delegate {
[Link]("<color=grey>[</color><color=red>ERROR</
color><color=grey>]</color> Could not copy creation date."); }, null, null);
}

public static void NarrateCreationDateGun()

{
if (GetGunInput(false))
{
var GunData = RenderGun();
RaycastHit Ray = [Link];
GameObject NewPointer = [Link];

if (GetGunInput(true))
{
VRRig gunTarget = [Link]<VRRig>();
if (gunTarget && !PlayerIsLocal(gunTarget) && [Link] >
cgdgd)
{
cgdgd = [Link] + 0.5f;
[Link](new GetAccountInfoRequest {
PlayFabId = GetPlayerFromVRRig(gunTarget).UserId }, delegate (GetAccountInfoResult
result) // Who designed this
{
string date = [Link]("MMMM
dd, yyyy at h mm");
[Link](SpeakText(date));
}, delegate {
[Link]("<color=grey>[</color><color=red>ERROR</
color><color=grey>]</color> Could not narrate creation date."); }, null, null);
}
}
}
}

public static void NarrateCreationDateSelf()

{
[Link](new GetAccountInfoRequest { PlayFabId =
[Link] }, delegate (GetAccountInfoResult result) // Who
designed this
{
string date = [Link]("MMMM dd, yyyy at
h mm");
[Link](SpeakText(date));
}, delegate {
[Link]("<color=grey>[</color><color=red>ERROR</
color><color=grey>]</color> Could not narrate creation date."); }, null, null);
}

public static void GrabPlayerInfo()

{
string text = "Room: " + [Link];
foreach ([Link] player in [Link])
{
float r = 0f;
float g = 0f;
float b = 0f;
string cosmetics = "";
try
{
VRRig plr = GetVRRigFromPlayer(player);
 r = [Link].r * 255;
g = [Link].g * 255;
b = [Link].b * 255;
cosmetics = [Link];
}
catch { [Link]("Failed to log colors, rig most likely
nonexistent"); }
try
{
text += "\n====================================\n";
text += [Link](new string[]
{
"Player Name: \"",
[Link],
"\", Player ID: \"",
[Link],
"\", Player Color: (R: ",
[Link](),
", G: ",
[Link](),
", B: ",
[Link](),
"), Cosmetics: ",
cosmetics
});
}
catch { [Link]("Failed to log player"); }
}
text += "\n====================================\n";
text += "Text file generated with ii's Stupid Menu";
string fileName = "iisStupidMenu/PlayerInfo/" +
[Link] + ".txt";

[Link](fileName, text);

string filePath =
[Link]([Link]().Location, fileName);
filePath = [Link]("BepInEx\\")[0] + fileName;

[Link](filePath);
}
}
}