using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("zabu")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("zabumod")]
[assembly: AssemblyTitle("zabumod")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace RepoAllPlayerCommands
{
[BepInPlugin("jp.repo.allplayercommands", "AllPlayerCommands", "0.5.2")]
public sealed class AllPlayerCommandsPlugin : BaseUnityPlugin
{
[HarmonyPatch(typeof(ChatManager), "MessageSend")]
public static class Patch_ChatManager_MessageSend
{
private static readonly string[] CmdKillAll = new string[4] { "/ka", "/killall", "/killallplayers", "/killplayerall" };
private static readonly string[] CmdReviveAll = new string[4] { "/ra", "/reviveall", "/reviveallplayers", "/reviveplayerall" };
private static readonly string[] CmdHealFullAll = new string[4] { "/ha", "/healall", "/healallplayers", "/healplayerall" };
private static readonly string[] CmdSummonAll = new string[4] { "/sa", "/summonall", "/summonallplayers", "/summonplayerall" };
private static readonly string[] CmdTruckAll = new string[4] { "/ta", "/truckall", "/truckallplayers", "/returntotruckall" };
private static readonly string[] CmdKnockbackAll = new string[4] { "/kba", "/knockbackall", "/knockall", "/impulseall" };
private static readonly string[] CmdDamageAll = new string[4] { "/dga", "/damageall", "/hurtall", "/hitall" };
private static readonly string[] CmdHealAmountAll = new string[4] { "/hga", "/healamountall", "/healaddall", "/healplusall" };
private static readonly string[] CmdExpressionAll = new string[4] { "/exa", "/expressionall", "/faceall", "/emoteall" };
private static readonly string[] CmdTtsAll = new string[4] { "/ttsa", "/ttsall", "/sayall", "/speakall" };
private static readonly string[] CmdTumbleAll = new string[2] { "/tba", "/tumbleall" };
private static readonly string[] CmdHpMaxAll = new string[2] { "/hpmaxall", "/hpmaxa" };
private static readonly string[] CmdFlickerAll = new string[2] { "/flickerall", "/flickera" };
private static readonly string[] CmdAnimSpeedAll = new string[4] { "/animspeedall", "/animspeeda", "/asall", "/animall" };
private static readonly string[] CmdPupilAll = new string[3] { "/pupilall", "/pupila", "/eyesall" };
private static readonly string[] CmdFallingAll = new string[3] { "/fallingall", "/fallinga", "/fallall" };
private static readonly string[] CmdResetPushAll = new string[4] { "/resetpushall", "/resetpusha", "/rpa", "/pushresetall" };
private static readonly string[] CmdTumbleWingsAll = new string[3] { "/tumblewingsall", "/wingsall", "/wa" };
private const int DefaultKnockback = 5;
private const int DefaultDamage = 10;
private const int DefaultHealAmount = 10;
private const int DefaultExpressionIndex = 4;
private const string DefaultTtsMessage = "Hello!!!";
private const float DefaultTumbleSeconds = 3f;
private const int DefaultHpMax = 200;
private const float DefaultFlickerMultiplier = 2f;
private const float DefaultAnimSpeedMulti = 0.5f;
private const float DefaultAnimIn = 0.05f;
private const float DefaultAnimOut = 0.2f;
private const float DefaultAnimTime = 3f;
private const float DefaultPupilMultiplier = 1.8f;
private const int DefaultPupilPrio = 10;
private const float DefaultPupilSpringIn = 25f;
private const float DefaultPupilDampIn = 0.8f;
private const float DefaultPupilSpringOut = 12f;
private const float DefaultPupilDampOut = 0.8f;
private const float DefaultPupilTime = 3f;
private static void Prefix(ChatManager __instance)
{
if (IsNullUnity(__instance))
{
LogWarn("MessageSend Prefix __instance null");
}
else if (IsNullUnity(__instance.playerAvatar))
{
LogWarn("MessageSend Prefix playerAvatar missing");
}
else
{
if (PlayerAvatar.instance != __instance.playerAvatar || !IsMasterClientOrSingleplayer())
{
return;
}
string chatMessage = __instance.chatMessage;
if (string.IsNullOrWhiteSpace(chatMessage))
{
return;
}
chatMessage = chatMessage.Trim();
if (!chatMessage.StartsWith("/"))
{
return;
}
SplitCommand(chatMessage, out string cmdLower, out string argRaw);
string[] chain;
if (IsAnyCmd(cmdLower, CmdKillAll))
{
ExecuteForAll("KillAll", delegate(PlayerAvatar p)
{
PlayerActions.Kill(p);
});
__instance.chatMessage = "";
}
else if (IsAnyCmd(cmdLower, CmdReviveAll))
{
ExecuteForAll("ReviveAll", delegate(PlayerAvatar p)
{
PlayerActions.Revive(p);
});
__instance.chatMessage = "";
}
else if (IsAnyCmd(cmdLower, CmdHealFullAll))
{
ExecuteForAll("HealFullAll", delegate(PlayerAvatar p)
{
PlayerActions.HealFull(p);
});
__instance.chatMessage = "";
}
else if (IsAnyCmd(cmdLower, CmdSummonAll))
{
StartStandUpThen("SummonAll", delegate
{
ExecuteForAll("SummonAll", delegate(PlayerAvatar p)
{
PlayerActions.SummonToLocal(p);
});
});
__instance.chatMessage = "";
}
else if (IsAnyCmd(cmdLower, CmdTruckAll))
{
StartStandUpThen("TruckAll", delegate
{
ExecuteForAll("TruckAll", delegate(PlayerAvatar p)
{
PlayerActions.ReturnToTruck(p);
});
});
__instance.chatMessage = "";
}
else if (IsAnyCmd(cmdLower, CmdKnockbackAll))
{
int strength = ParseIntOrDefault(argRaw, 5);
PlayerAvatar origin = PlayerAvatar.instance;
ExecuteForAll("KnockbackAll strength=" + strength, delegate(PlayerAvatar p)
{
PlayerActions.Knockback(p, strength, origin);
});
__instance.chatMessage = "";
}
else if (IsAnyCmd(cmdLower, CmdDamageAll))
{
int damage = ParseIntOrDefault(argRaw, 10);
ExecuteForAll("DamageAll damage=" + damage, delegate(PlayerAvatar p)
{
PlayerActions.DamageAmount(p, damage);
});
__instance.chatMessage = "";
}
else if (IsAnyCmd(cmdLower, CmdHealAmountAll))
{
int heal = ParseIntOrDefault(argRaw, 10);
ExecuteForAll("HealAmountAll heal=" + heal, delegate(PlayerAvatar p)
{
PlayerActions.HealAmount(p, heal);
});
__instance.chatMessage = "";
}
else if (IsAnyCmd(cmdLower, CmdExpressionAll))
{
int index = ParseIntOrDefault(argRaw, 4);
ExecuteForAll("ExpressionAll index=" + index, delegate(PlayerAvatar p)
{
PlayerActions.Expression(p, index);
});
__instance.chatMessage = "";
}
else if (IsAnyCmd(cmdLower, CmdTtsAll))
{
string msg = (string.IsNullOrWhiteSpace(argRaw) ? "Hello!!!" : argRaw);
ExecuteForAll("TTSAll msg=" + msg, delegate(PlayerAvatar p)
{
PlayerActions.TtsSpeak(p, msg);
});
__instance.chatMessage = "";
}
else if (IsAnyCmd(cmdLower, CmdTumbleWingsAll))
{
string text = (string.IsNullOrWhiteSpace(argRaw) ? "on" : argRaw.Trim().ToLowerInvariant());
if (text == "off" || text == "0" || text == "false")
{
StopPinkWingsLoop();
ExecuteForAll("TumbleWingsAll off", delegate(PlayerAvatar p)
{
PlayerActions.WingsVisuals(p, visualsActive: false, pink: false);
});
}
else if (text == "pink" || text == "p")
{
StartPinkWingsLoop();
}
else
{
StopPinkWingsLoop();
ExecuteForAll("TumbleWingsAll on", delegate(PlayerAvatar p)
{
PlayerActions.WingsVisuals(p, visualsActive: true, pink: false);
});
}
__instance.chatMessage = "";
}
else if (IsAnyCmd(cmdLower, CmdTumbleAll))
{
string text2 = (string.IsNullOrWhiteSpace(argRaw) ? "" : argRaw.Trim().ToLowerInvariant());
if (text2 == "off" || text2 == "0" || text2 == "false")
{
StopTimedTumble();
ExecuteForAll("TumbleAll off", delegate(PlayerAvatar p)
{
PlayerActions.SetTumble(p, isTumbling: false);
});
}
else if (text2 == "on" || text2 == "true")
{
StopTimedTumble();
ExecuteForAll("TumbleAll on", delegate(PlayerAvatar p)
{
PlayerActions.SetTumble(p, isTumbling: true);
});
}
else
{
float num = ParseFloatOrDefault(argRaw, 3f);
if (num <= 0f)
{
StopTimedTumble();
ExecuteForAll("TumbleAll off", delegate(PlayerAvatar p)
{
PlayerActions.SetTumble(p, isTumbling: false);
});
}
else
{
StartTimedTumble(num);
}
}
__instance.chatMessage = "";
}
else if (IsAnyCmd(cmdLower, CmdHpMaxAll))
{
int max = ParseIntOrDefault(argRaw, 200);
if (max < 1)
{
max = 1;
}
ExecuteForAll("HpMaxAll max=" + max, delegate(PlayerAvatar p)
{
PlayerActions.SetHpMax(p, max);
});
__instance.chatMessage = "";
}
else if (IsAnyCmd(cmdLower, CmdFlickerAll))
{
float multi = ParseFloatOrDefault(argRaw, 2f);
if (multi < 0f)
{
multi = 0f;
}
ExecuteForAll("FlickerAll multi=" + multi.ToString(CultureInfo.InvariantCulture), delegate(PlayerAvatar p)
{
PlayerActions.Flicker(p, multi);
});
__instance.chatMessage = "";
}
else if (IsAnyCmd(cmdLower, CmdAnimSpeedAll))
{
string[] array = SplitTokens(argRaw);
if (array.Length >= 1 && (array[0] == "off" || array[0] == "0" || array[0] == "false"))
{
ExecuteForAll("AnimSpeedAll off", delegate(PlayerAvatar p)
{
PlayerActions.OverrideAnimSpeed(p, active: false, 1f, 0.05f, 0.2f, 0.1f);
});
}
else
{
float speed = ((array.Length >= 1) ? ParseFloatOrDefault(array[0], 0.5f) : 0.5f);
float tin = ((array.Length >= 2) ? ParseFloatOrDefault(array[1], 0.05f) : 0.05f);
float tout = ((array.Length >= 3) ? ParseFloatOrDefault(array[2], 0.2f) : 0.2f);
float time2 = ((array.Length >= 4) ? ParseFloatOrDefault(array[3], 3f) : 3f);
ExecuteForAll("AnimSpeedAll on speed=" + speed.ToString(CultureInfo.InvariantCulture) + " in=" + tin.ToString(CultureInfo.InvariantCulture) + " out=" + tout.ToString(CultureInfo.InvariantCulture) + " time=" + time2.ToString(CultureInfo.InvariantCulture), delegate(PlayerAvatar p)
{
PlayerActions.OverrideAnimSpeed(p, active: true, speed, tin, tout, time2);
});
}
__instance.chatMessage = "";
}
else if (IsAnyCmd(cmdLower, CmdPupilAll))
{
string[] array2 = SplitTokens(argRaw);
if (array2.Length >= 1 && (array2[0] == "off" || array2[0] == "0" || array2[0] == "false"))
{
ExecuteForAll("PupilAll off", delegate(PlayerAvatar p)
{
PlayerActions.OverridePupil(p, active: false, 1f, 10, 25f, 0.8f, 12f, 0.8f, 0.1f);
});
}
else
{
float mult = ((array2.Length >= 1) ? ParseFloatOrDefault(array2[0], 1.8f) : 1.8f);
int prio = ((array2.Length >= 2) ? ParseIntOrDefault(array2[1], 10) : 10);
float spIn = ((array2.Length >= 3) ? ParseFloatOrDefault(array2[2], 25f) : 25f);
float dpIn = ((array2.Length >= 4) ? ParseFloatOrDefault(array2[3], 0.8f) : 0.8f);
float spOut = ((array2.Length >= 5) ? ParseFloatOrDefault(array2[4], 12f) : 12f);
float dpOut = ((array2.Length >= 6) ? ParseFloatOrDefault(array2[5], 0.8f) : 0.8f);
float time = ((array2.Length >= 7) ? ParseFloatOrDefault(array2[6], 3f) : 3f);
ExecuteForAll("PupilAll on mult=" + mult.ToString(CultureInfo.InvariantCulture) + " prio=" + prio + " time=" + time.ToString(CultureInfo.InvariantCulture), delegate(PlayerAvatar p)
{
PlayerActions.OverridePupil(p, active: true, mult, prio, spIn, dpIn, spOut, dpOut, time);
});
}
__instance.chatMessage = "";
}
else if (IsAnyCmd(cmdLower, CmdFallingAll))
{
string text3 = (string.IsNullOrWhiteSpace(argRaw) ? "on" : argRaw.Trim().ToLowerInvariant());
bool falling = !(text3 == "off") && !(text3 == "0") && !(text3 == "false");
ExecuteForAll("FallingAll falling=" + falling, delegate(PlayerAvatar p)
{
PlayerActions.SetFalling(p, falling);
});
__instance.chatMessage = "";
}
else if (IsAnyCmd(cmdLower, CmdResetPushAll))
{
ExecuteForAll("ResetPhysPusherAll", delegate(PlayerAvatar p)
{
PlayerActions.ResetPhysPusher(p);
});
__instance.chatMessage = "";
}
else if (string.IsNullOrWhiteSpace(argRaw) && TryParseChainedSimple(cmdLower, out chain))
{
ExecuteChainedSimple(chain);
__instance.chatMessage = "";
}
}
}
private static bool TryParseChainedSimple(string cmdLower, out string[] chain)
{
chain = null;
if (string.IsNullOrWhiteSpace(cmdLower))
{
return false;
}
string text = cmdLower.Trim().ToLowerInvariant();
if (!text.StartsWith("/"))
{
return false;
}
text = text.Substring(1);
if (text.Length < 4)
{
return false;
}
if (text.Length % 2 != 0)
{
return false;
}
int num = text.Length / 2;
if (num < 2)
{
return false;
}
List<string> list = new List<string>(num);
for (int i = 0; i < num; i++)
{
string text2 = text.Substring(i * 2, 2);
if (text2 != "ra" && text2 != "ha" && text2 != "ka")
{
return false;
}
list.Add(text2);
}
chain = list.ToArray();
return true;
}
private static void ExecuteChainedSimple(string[] chain)
{
for (int i = 0; i < chain.Length; i++)
{
switch (chain[i])
{
case "ra":
ExecuteForAll("ReviveAll(chain)", delegate(PlayerAvatar p)
{
PlayerActions.Revive(p);
});
break;
case "ha":
ExecuteForAll("HealFullAll(chain)", delegate(PlayerAvatar p)
{
PlayerActions.HealFull(p);
});
break;
case "ka":
ExecuteForAll("KillAll(chain)", delegate(PlayerAvatar p)
{
PlayerActions.Kill(p);
});
break;
}
}
}
private static void StartStandUpThen(string actionName, Action after)
{
if ((Object)(object)Instance != (Object)null)
{
((MonoBehaviour)Instance).StartCoroutine(Instance.CoStandUpThen(actionName, after));
return;
}
ExecuteForAll("StandUpBefore" + actionName, delegate(PlayerAvatar p)
{
PlayerActions.StandUpFromTumble(p);
});
after();
}
private static void StartPinkWingsLoop()
{
if (!((Object)(object)Instance == (Object)null))
{
Instance._pinkWingsLoopEnabled = true;
if (Instance._pinkWingsLoopCo == null)
{
Instance._pinkWingsLoopCo = ((MonoBehaviour)Instance).StartCoroutine(Instance.CoPinkWingsLoop());
}
}
}
private static void StopPinkWingsLoop()
{
if (!((Object)(object)Instance == (Object)null))
{
Instance._pinkWingsLoopEnabled = false;
if (Instance._pinkWingsLoopCo != null)
{
((MonoBehaviour)Instance).StopCoroutine(Instance._pinkWingsLoopCo);
Instance._pinkWingsLoopCo = null;
}
}
}
private static void StartTimedTumble(float seconds)
{
if ((Object)(object)Instance == (Object)null)
{
ExecuteForAll("TumbleAll timed start(sec=" + seconds.ToString(CultureInfo.InvariantCulture) + ")", delegate(PlayerAvatar p)
{
PlayerActions.SetTumble(p, isTumbling: true);
});
}
else
{
Instance.StopTimedTumbleInternal();
Instance._tumbleTimedCo = ((MonoBehaviour)Instance).StartCoroutine(Instance.CoTimedTumble(seconds));
}
}
private static void StopTimedTumble()
{
if (!((Object)(object)Instance == (Object)null))
{
Instance.StopTimedTumbleInternal();
}
}
private static void SplitCommand(string raw, out string cmdLower, out string argRaw)
{
cmdLower = "";
argRaw = "";
string[] array = raw.Split(new char[1] { ' ' }, 2, StringSplitOptions.RemoveEmptyEntries);
if (array.Length != 0)
{
cmdLower = array[0].Trim().ToLowerInvariant();
argRaw = ((array.Length >= 2) ? array[1].Trim() : "");
}
}
private static string[] SplitTokens(string argRaw)
{
if (string.IsNullOrWhiteSpace(argRaw))
{
return Array.Empty<string>();
}
return argRaw.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
}
private static int ParseIntOrDefault(string arg, int defaultValue)
{
if (string.IsNullOrWhiteSpace(arg))
{
return defaultValue;
}
string s = arg.Trim().Split(new char[1] { ' ' }, 2, StringSplitOptions.RemoveEmptyEntries)[0];
if (int.TryParse(s, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
{
return result;
}
return defaultValue;
}
private static float ParseFloatOrDefault(string arg, float defaultValue)
{
if (string.IsNullOrWhiteSpace(arg))
{
return defaultValue;
}
string s = arg.Trim().Split(new char[1] { ' ' }, 2, StringSplitOptions.RemoveEmptyEntries)[0];
if (float.TryParse(s, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
{
return result;
}
return defaultValue;
}
}
internal static class PlayerActions
{
public static void StandUpFromTumble(PlayerAvatar avatar)
{
if (IsNullUnity(avatar))
{
return;
}
PlayerTumble val = null;
try
{
val = avatar.tumble;
}
catch
{
val = null;
}
if (IsNullUnity(val))
{
return;
}
try
{
val.TumbleRequest(false, true);
}
catch
{
}
}
public static void SetTumble(PlayerAvatar avatar, bool isTumbling)
{
if (IsNullUnity(avatar))
{
return;
}
PlayerTumble val = null;
try
{
val = avatar.tumble;
}
catch
{
val = null;
}
if (IsNullUnity(val))
{
return;
}
try
{
val.TumbleSet(isTumbling, false);
}
catch
{
try
{
val.TumbleRequest(isTumbling, false);
}
catch
{
}
}
}
public static void Kill(PlayerAvatar avatar)
{
if (IsNullUnity(avatar))
{
return;
}
try
{
avatar.PlayerDeath(-1);
}
catch
{
}
}
public static void Revive(PlayerAvatar avatar)
{
if (IsNullUnity(avatar))
{
return;
}
try
{
if (avatar.deadSet && !IsNullUnity(avatar.playerDeathHead))
{
avatar.playerDeathHead.inExtractionPoint = true;
avatar.Revive(false);
}
}
catch
{
}
finally
{
try
{
avatar.playerDeathHead.inExtractionPoint = false;
}
catch
{
}
}
}
public static void HealFull(PlayerAvatar avatar)
{
if (IsNullUnity(avatar))
{
return;
}
PlayerHealth val = null;
try
{
val = avatar.playerHealth;
}
catch
{
val = null;
}
if (IsNullUnity(val))
{
return;
}
try
{
val.HealOther(9999, true);
}
catch
{
}
}
public static void HealAmount(PlayerAvatar avatar, int amount)
{
if (IsNullUnity(avatar) || amount <= 0)
{
return;
}
PlayerHealth val = null;
try
{
val = avatar.playerHealth;
}
catch
{
val = null;
}
if (IsNullUnity(val))
{
return;
}
try
{
val.HealOther(amount, true);
}
catch
{
}
}
public static void DamageAmount(PlayerAvatar avatar, int damage)
{
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
if (IsNullUnity(avatar) || damage <= 0)
{
return;
}
PlayerHealth val = null;
try
{
val = avatar.playerHealth;
}
catch
{
val = null;
}
if (IsNullUnity(val))
{
return;
}
try
{
val.HurtOther(damage, Vector3.zero, false, -1);
}
catch
{
}
}
public static void Knockback(PlayerAvatar avatar, int strength, PlayerAvatar origin)
{
//IL_008a: Unknown result type (might be due to invalid IL or missing references)
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
//IL_0096: Unknown result type (might be due to invalid IL or missing references)
//IL_0098: Unknown result type (might be due to invalid IL or missing references)
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
//IL_0083: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
if (IsNullUnity(avatar) || strength <= 0)
{
return;
}
Vector3 forward = Vector3.forward;
try
{
if (!IsNullUnity(origin))
{
Vector3 val = ((Component)avatar).transform.position - ((Component)origin).transform.position;
forward = ((((Vector3)(ref val)).sqrMagnitude > 0.01f) ? ((Vector3)(ref val)).normalized : ((Component)origin).transform.forward);
}
else
{
forward = ((Component)avatar).transform.forward;
}
}
catch
{
forward = Vector3.forward;
}
float num = strength;
Vector3 val2 = forward * num + Vector3.up * (num * 0.2f);
try
{
avatar.ForceImpulse(val2);
}
catch
{
}
}
public static void Expression(PlayerAvatar avatar, int index)
{
if (IsNullUnity(avatar) || index < 0)
{
return;
}
PlayerExpression val = null;
try
{
val = avatar.playerExpression;
}
catch
{
val = null;
}
if (IsNullUnity(val))
{
return;
}
int num = 0;
try
{
num = ((val.expressions != null) ? val.expressions.Count : 0);
}
catch
{
num = 0;
}
if (num <= 0 || index >= num)
{
return;
}
try
{
avatar.PlayerExpressionSet(index, 1f);
}
catch
{
}
}
public static void TtsSpeak(PlayerAvatar avatar, string message)
{
if (IsNullUnity(avatar) || string.IsNullOrWhiteSpace(message))
{
return;
}
string text = message.Trim();
if (text.StartsWith("/"))
{
text = " " + text;
}
try
{
avatar.ChatMessageSend(text);
}
catch
{
}
}
public static void WingsVisuals(PlayerAvatar avatar, bool visualsActive, bool pink)
{
if (IsNullUnity(avatar))
{
return;
}
try
{
if (!IsNullUnity(avatar.upgradeTumbleWingsLogic))
{
avatar.UpgradeTumbleWingsVisualsActive(visualsActive, pink);
}
}
catch
{
}
}
public static void SetHpMax(PlayerAvatar avatar, int max)
{
if (IsNullUnity(avatar))
{
return;
}
PlayerHealth val = null;
try
{
val = avatar.playerHealth;
}
catch
{
val = null;
}
if (IsNullUnity(val) || IsNullUnity(val.photonView))
{
return;
}
int value = 0;
int value2 = 0;
F_PlayerHealth_health.TryGetValue(val, out value);
F_PlayerHealth_maxHealth.TryGetValue(val, out value2);
int num = value;
if (num > max)
{
num = max;
}
if (num < 1)
{
num = 1;
}
try
{
val.photonView.RPC("UpdateHealthRPC", (RpcTarget)0, new object[3] { num, max, true });
}
catch
{
}
}
public static void Flicker(PlayerAvatar avatar, float multiplier)
{
if (IsNullUnity(avatar))
{
return;
}
try
{
avatar.FlashlightFlicker(multiplier);
}
catch
{
}
}
public static void OverrideAnimSpeed(PlayerAvatar avatar, bool active, float speedMulti, float inSec, float outSec, float time)
{
if (IsNullUnity(avatar) || IsNullUnity(avatar.photonView))
{
return;
}
try
{
avatar.photonView.RPC("OverrideAnimationSpeedActivateRPC", (RpcTarget)0, new object[5] { active, speedMulti, inSec, outSec, time });
}
catch
{
}
}
public static void OverridePupil(PlayerAvatar avatar, bool active, float multiplier, int prio, float springIn, float dampIn, float springOut, float dampOut, float time)
{
if (IsNullUnity(avatar) || IsNullUnity(avatar.photonView))
{
return;
}
try
{
avatar.photonView.RPC("OverridePupilSizeActivateRPC", (RpcTarget)0, new object[8] { active, multiplier, prio, springIn, dampIn, springOut, dampOut, time });
}
catch
{
}
}
public static void SetFalling(PlayerAvatar avatar, bool falling)
{
if (IsNullUnity(avatar) || IsNullUnity(avatar.photonView))
{
return;
}
try
{
avatar.photonView.RPC("FallingSetRPC", (RpcTarget)0, new object[1] { falling });
}
catch
{
}
}
public static void ResetPhysPusher(PlayerAvatar avatar)
{
if (IsNullUnity(avatar) || IsNullUnity(avatar.photonView))
{
return;
}
try
{
avatar.photonView.RPC("ResetPhysPusher", (RpcTarget)0, Array.Empty<object>());
}
catch
{
}
}
public static void SummonToLocal(PlayerAvatar target)
{
if (!IsNullUnity(target))
{
PlayerAvatar instance = PlayerAvatar.instance;
if (!IsNullUnity(instance))
{
Teleport(target, instance);
}
}
}
public static void ReturnToTruck(PlayerAvatar avatar)
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
if (!IsNullUnity(avatar) && !IsNullUnity(TruckSafetySpawnPoint.instance))
{
Vector3 position = ((Component)TruckSafetySpawnPoint.instance).transform.position;
Quaternion rotation = ((Component)TruckSafetySpawnPoint.instance).transform.rotation;
Teleport(avatar, position, rotation);
}
}
private static void Teleport(PlayerAvatar from, PlayerAvatar to)
{
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
//IL_009c: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_0090: Unknown result type (might be due to invalid IL or missing references)
if (IsNullUnity(from) || IsNullUnity(to))
{
return;
}
Vector3 position = ((Component)to).transform.position;
Quaternion rotation = ((Component)to).transform.rotation;
try
{
if (to.deadSet && !IsNullUnity(to.playerDeathHead) && !IsNullUnity(to.playerDeathHead.physGrabObject))
{
position = ((Component)to.playerDeathHead.physGrabObject).transform.position;
rotation = ((Component)to.playerDeathHead.physGrabObject).transform.rotation;
}
}
catch
{
}
Teleport(from, position, rotation);
}
private static void Teleport(PlayerAvatar from, Vector3 pos, Quaternion rot)
{
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
if (IsNullUnity(from))
{
return;
}
try
{
if (from.deadSet && !IsNullUnity(from.playerDeathHead) && !IsNullUnity(from.playerDeathHead.physGrabObject))
{
from.playerDeathHead.physGrabObject.Teleport(pos, rot);
return;
}
}
catch
{
}
try
{
from.Spawn(pos, rot);
}
catch
{
}
}
}
internal sealed class FieldInfoCache<T>
{
private readonly FieldInfo _fi;
public FieldInfoCache(Type type, string fieldName)
{
_fi = AccessTools.Field(type, fieldName);
}
public bool TryGetValue(object instance, out T value)
{
value = default(T);
if (_fi == null || instance == null)
{
return false;
}
try
{
object value2 = _fi.GetValue(instance);
if (value2 is T)
{
value = (T)value2;
return true;
}
}
catch
{
}
return false;
}
}
[CompilerGenerated]
private sealed class <CoPinkWingsLoop>d__11 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public AllPlayerCommandsPlugin <>4__this;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <CoPinkWingsLoop>d__11(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
break;
case 1:
<>1__state = -1;
break;
}
if (<>4__this._pinkWingsLoopEnabled)
{
ExecuteForAll("TumbleWingsAll pink tick", delegate(PlayerAvatar p)
{
PlayerActions.WingsVisuals(p, visualsActive: true, pink: true);
});
<>2__current = (object)new WaitForSeconds(0.5f);
<>1__state = 1;
return true;
}
<>4__this._pinkWingsLoopCo = null;
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <CoStandUpThen>d__10 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public string actionName;
public Action after;
public AllPlayerCommandsPlugin <>4__this;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <CoStandUpThen>d__10(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
ExecuteForAll("StandUpBefore" + actionName, delegate(PlayerAvatar p)
{
PlayerActions.StandUpFromTumble(p);
});
<>2__current = null;
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
after();
return false;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <CoTimedTumble>d__12 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public float seconds;
public AllPlayerCommandsPlugin <>4__this;
private float <remain>5__1;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <CoTimedTumble>d__12(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
ExecuteForAll("TumbleAll timed on", delegate(PlayerAvatar p)
{
PlayerActions.SetTumble(p, isTumbling: true);
});
<remain>5__1 = seconds;
break;
case 1:
<>1__state = -1;
break;
}
if (<remain>5__1 > 0f)
{
<remain>5__1 -= Time.deltaTime;
<>2__current = null;
<>1__state = 1;
return true;
}
ExecuteForAll("TumbleAll timed off", delegate(PlayerAvatar p)
{
PlayerActions.SetTumble(p, isTumbling: false);
});
<>4__this._tumbleTimedCo = null;
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
internal static AllPlayerCommandsPlugin Instance;
internal static ManualLogSource LogSource;
private Harmony _harmony;
private Coroutine _pinkWingsLoopCo;
private bool _pinkWingsLoopEnabled;
private Coroutine _tumbleTimedCo;
private static readonly FieldInfoCache<int> F_PlayerHealth_health = new FieldInfoCache<int>(typeof(PlayerHealth), "health");
private static readonly FieldInfoCache<int> F_PlayerHealth_maxHealth = new FieldInfoCache<int>(typeof(PlayerHealth), "maxHealth");
private void Awake()
{
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Expected O, but got Unknown
Instance = this;
LogSource = ((BaseUnityPlugin)this).Logger;
LogInfo("Loaded");
_harmony = new Harmony("jp.repo.allplayercommands.harmony");
_harmony.PatchAll();
LogInfo("Harmony patched");
}
[IteratorStateMachine(typeof(<CoStandUpThen>d__10))]
private IEnumerator CoStandUpThen(string actionName, Action after)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <CoStandUpThen>d__10(0)
{
<>4__this = this,
actionName = actionName,
after = after
};
}
[IteratorStateMachine(typeof(<CoPinkWingsLoop>d__11))]
private IEnumerator CoPinkWingsLoop()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <CoPinkWingsLoop>d__11(0)
{
<>4__this = this
};
}
[IteratorStateMachine(typeof(<CoTimedTumble>d__12))]
private IEnumerator CoTimedTumble(float seconds)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <CoTimedTumble>d__12(0)
{
<>4__this = this,
seconds = seconds
};
}
private void StopTimedTumbleInternal()
{
if (_tumbleTimedCo != null)
{
((MonoBehaviour)this).StopCoroutine(_tumbleTimedCo);
_tumbleTimedCo = null;
}
}
private static void ExecuteForAll(string actionName, Action<PlayerAvatar> action)
{
if (!IsMasterClientOrSingleplayer())
{
return;
}
List<PlayerAvatar> allPlayers = GetAllPlayers();
for (int i = 0; i < allPlayers.Count; i++)
{
PlayerAvatar val = allPlayers[i];
if (!IsNullUnity(val))
{
try
{
action(val);
}
catch (Exception ex)
{
LogError("Command failure " + actionName + " target=" + PlayerLabel(val) + "\n" + ex);
}
}
}
}
private static List<PlayerAvatar> GetAllPlayers()
{
Dictionary<int, PlayerAvatar> dictionary = new Dictionary<int, PlayerAvatar>();
try
{
List<PlayerAvatar> list = SemiFunc.PlayerGetList();
if (list != null)
{
for (int i = 0; i < list.Count; i++)
{
PlayerAvatar val = list[i];
if (!IsNullUnity(val))
{
int instanceID;
try
{
instanceID = ((Object)val).GetInstanceID();
}
catch
{
continue;
}
dictionary[instanceID] = val;
}
}
}
}
catch
{
}
if (dictionary.Count > 0)
{
return new List<PlayerAvatar>(dictionary.Values);
}
try
{
PlayerAvatar[] array = Resources.FindObjectsOfTypeAll<PlayerAvatar>();
foreach (PlayerAvatar val2 in array)
{
if (!IsNullUnity(val2))
{
int instanceID2;
try
{
instanceID2 = ((Object)val2).GetInstanceID();
}
catch
{
continue;
}
dictionary[instanceID2] = val2;
}
}
}
catch
{
}
return new List<PlayerAvatar>(dictionary.Values);
}
private static bool IsMasterClientOrSingleplayer()
{
try
{
return SemiFunc.IsMasterClientOrSingleplayer();
}
catch
{
return !PhotonNetwork.InRoom || PhotonNetwork.IsMasterClient;
}
}
private static bool IsAnyCmd(string cmdLower, IEnumerable<string> cmds)
{
foreach (string cmd in cmds)
{
if (string.Equals(cmdLower, cmd, StringComparison.OrdinalIgnoreCase))
{
return true;
}
}
return false;
}
private static string PlayerLabel(PlayerAvatar avatar)
{
if (IsNullUnity(avatar))
{
return "<NullPlayer>";
}
try
{
string text = SemiFunc.PlayerGetName(avatar);
string text2 = SemiFunc.PlayerGetSteamID(avatar);
return text + " (" + text2 + ")";
}
catch
{
try
{
return ((Object)avatar).name;
}
catch
{
return "<UnknownPlayer>";
}
}
}
private static bool IsNullUnity(object obj)
{
if (obj == null)
{
return true;
}
Object val = (Object)((obj is Object) ? obj : null);
if (val != null)
{
return val == (Object)null;
}
return false;
}
internal static void LogInfo(string message)
{
Debug.Log((object)("[AllPlayerCommands] " + message));
if (LogSource != null)
{
LogSource.LogInfo((object)message);
}
}
internal static void LogWarn(string message)
{
Debug.LogWarning((object)("[AllPlayerCommands] " + message));
if (LogSource != null)
{
LogSource.LogWarning((object)message);
}
}
internal static void LogError(string message)
{
Debug.LogError((object)("[AllPlayerCommands] " + message));
if (LogSource != null)
{
LogSource.LogError((object)message);
}
}
}
}
