using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Logging;
using Brigadier.NET;
using Brigadier.NET.ArgumentTypes;
using Brigadier.NET.Builder;
using Brigadier.NET.Context;
using Brigadier.NET.Tree;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Rumi.BrigadierForLethalCompany;
using Rumi.BrigadierForLethalCompany.API;
using Rumi.BrigadierForLethalCompany.API.ArgumentTypes;
using Rumi.BrigadierForLethalCompany.API.ArgumentTypes.Selectors;
using StaticNetcodeLib;
using Unity.Netcode;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
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;
}
}
}
namespace Rumi.LethalCheat
{
internal static class Debug
{
public static void Log(object data)
{
ManualLogSource? logger = LCheatPlugin.logger;
if (logger != null)
{
logger.LogInfo(data);
}
}
public static void LogWarning(object data)
{
ManualLogSource? logger = LCheatPlugin.logger;
if (logger != null)
{
logger.LogWarning(data);
}
}
public static void LogError(object data)
{
ManualLogSource? logger = LCheatPlugin.logger;
if (logger != null)
{
logger.LogError(data);
}
}
}
[BepInPlugin("Rumi.LethalCheat", "LethalCheat", "2.1.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public sealed class LCheatPlugin : BaseUnityPlugin
{
public const string modGuid = "Rumi.LethalCheat";
public const string modName = "LethalCheat";
public const string modVersion = "2.1.0";
internal static ManualLogSource? logger { get; private set; } = null;
internal static Harmony harmony { get; } = new Harmony("Rumi.LethalCheat");
private void Awake()
{
logger = ((BaseUnityPlugin)this).Logger;
Debug.Log("Start loading plugin...");
Debug.Log("Plugin LethalCheat is loaded!");
}
}
}
namespace Rumi.LethalCheat.API.Commands
{
public sealed class CreditCommand : ServerCommand
{
public const string resultGetText = "The credit is {0}";
public const string resultAddText = "Add the credit to {0}";
public const string resultSetText = "Set the credit to {0}";
private CreditCommand()
{
}
public override void Register()
{
ServerCommand.dispatcher.Register((Func<IArgumentContext<ServerCommandSource>, LiteralArgumentBuilder<ServerCommandSource>>)((IArgumentContext<ServerCommandSource> x) => ((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "credit")).Requires((Predicate<ServerCommandSource>)((ServerCommandSource x) => x.isOp))).Then<LiteralCommandNode<ServerCommandSource>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "get")).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
int credit = GetCredit();
x.Source.SendCommandResult($"The credit is {credit}", false);
return credit;
})))).Then<LiteralCommandNode<ServerCommandSource>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "add")).Then<ArgumentCommandNode<ServerCommandSource, int>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, int>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, int>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, int>, ArgumentCommandNode<ServerCommandSource, int>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, int>(x, "credit", (IArgumentType<int>)(object)Arguments.Integer(0, int.MaxValue))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
int integer2 = Arguments.GetInteger<ServerCommandSource>(x, "credit");
SetCredit(GetCredit() + integer2);
x.Source.SendCommandResult($"Add the credit to {integer2}", true);
return integer2;
})))))).Then<LiteralCommandNode<ServerCommandSource>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "set")).Then<ArgumentCommandNode<ServerCommandSource, int>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, int>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, int>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, int>, ArgumentCommandNode<ServerCommandSource, int>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, int>(x, "credit", (IArgumentType<int>)(object)Arguments.Integer(0, int.MaxValue))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
int integer = Arguments.GetInteger<ServerCommandSource>(x, "credit");
SetCredit(integer);
x.Source.SendCommandResult($"Set the credit to {integer}", true);
return integer;
})))))));
}
public static int GetCredit()
{
if ((Object)(object)NetworkManager.Singleton == (Object)null || !NetworkManager.Singleton.IsServer)
{
return 0;
}
return Object.FindAnyObjectByType<Terminal>().groupCredits;
}
public static void SetCredit(int credit)
{
if (!((Object)(object)NetworkManager.Singleton == (Object)null) && NetworkManager.Singleton.IsServer)
{
Terminal val = Object.FindAnyObjectByType<Terminal>();
val.useCreditsCooldown = true;
val.groupCredits = credit;
val.SyncGroupCreditsServerRpc(val.groupCredits, val.numberOfItemsInDropship);
}
}
}
public sealed class DamageCommand : ServerCommand
{
public const string resultText = "Applied {0} damage to {1}";
private DamageCommand()
{
}
public override void Register()
{
ServerCommand.dispatcher.Register((Func<IArgumentContext<ServerCommandSource>, LiteralArgumentBuilder<ServerCommandSource>>)((IArgumentContext<ServerCommandSource> x) => ((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "damage")).Requires((Predicate<ServerCommandSource>)((ServerCommandSource x) => x.isOp))).Then<ArgumentCommandNode<ServerCommandSource, int>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, int>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, int>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, int>, ArgumentCommandNode<ServerCommandSource, int>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, int>(x, "amount", (IArgumentType<int>)(object)Arguments.Integer(int.MinValue, int.MaxValue))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
if ((Object)(object)x.Source.sender != (Object)null)
{
int integer2 = Arguments.GetInteger<ServerCommandSource>(x, "amount");
DamageEntity(x.Source.sender, integer2);
x.Source.SendCommandResult($"Applied {integer2} damage to {BFLCUtility.GetEntityName(x.Source.sender)}", true);
return 1;
}
return 0;
})))).Then<ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, SelectorArgumentValue>, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, SelectorArgumentValue>(x, "targets", (IArgumentType<SelectorArgumentValue>)(object)LethalArguments.Selector(false, false))).Then<ArgumentCommandNode<ServerCommandSource, int>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, int>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, int>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, int>, ArgumentCommandNode<ServerCommandSource, int>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, int>(x, "amount", (IArgumentType<int>)(object)Arguments.Integer(int.MinValue, int.MaxValue))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
SelectorArgumentValue selector = LethalArguments.GetSelector<ServerCommandSource>(x, "targets");
IEnumerable<NetworkBehaviour> entitys = ((SelectorArgumentValue)(ref selector)).GetEntitys(x.Source);
int integer = Arguments.GetInteger<ServerCommandSource>(x, "amount");
int num = 0;
foreach (NetworkBehaviour item in entitys)
{
if ((item is PlayerControllerB || item is EnemyAI) ? true : false)
{
try
{
DamageEntity(item, integer);
num++;
}
catch (Exception data)
{
Debug.LogError(data);
}
}
}
x.Source.SendCommandResult($"Applied {integer} damage to {BFLCUtility.GetEntityName(entitys, num)}", true);
return num;
})))))));
}
public static void DamageEntity(NetworkBehaviour entity, int damage)
{
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)NetworkManager.Singleton == (Object)null) && NetworkManager.Singleton.IsServer && ((entity is PlayerControllerB || entity is EnemyAI) ? true : false))
{
InternalDamageEntityClientRpc(NetworkBehaviourReference.op_Implicit(entity), damage);
}
}
[ClientRpc]
private static void InternalDamageEntityClientRpc(NetworkBehaviourReference entityRef, int damage)
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
NetworkBehaviour val = default(NetworkBehaviour);
if (!((NetworkBehaviourReference)(ref entityRef)).TryGet(ref val, (NetworkManager)null))
{
return;
}
PlayerControllerB val2 = (PlayerControllerB)(object)((val is PlayerControllerB) ? val : null);
if (val2 != null)
{
val2.DamagePlayer(damage, true, true, (CauseOfDeath)0, 0, false, default(Vector3));
return;
}
EnemyAI val3 = (EnemyAI)(object)((val is EnemyAI) ? val : null);
if (val3 != null)
{
val3.HitEnemy(damage, (PlayerControllerB)null, true, -1);
}
}
}
public sealed class DestroyCommand : ServerCommand
{
public const string resultText = "Destroyed {0}";
private DestroyCommand()
{
}
public override void Register()
{
ServerCommand.dispatcher.Register((Func<IArgumentContext<ServerCommandSource>, LiteralArgumentBuilder<ServerCommandSource>>)((IArgumentContext<ServerCommandSource> x) => ((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "destroy")).Requires((Predicate<ServerCommandSource>)((ServerCommandSource x) => x.isOp))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
if ((Object)(object)x.Source.sender != (Object)null && (Object)(object)x.Source.player == (Object)null)
{
DestroyEntity(x.Source.sender);
x.Source.SendCommandResult($"Destroyed {BFLCUtility.GetEntityName(x.Source.sender)}", true);
return 1;
}
return 0;
})).Then<ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, SelectorArgumentValue>, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, SelectorArgumentValue>(x, "targets", (IArgumentType<SelectorArgumentValue>)(object)LethalArguments.Selector(false, false))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)x.Source.sender != (Object)null)
{
SelectorArgumentValue selector = LethalArguments.GetSelector<ServerCommandSource>(x, "targets");
IEnumerable<NetworkBehaviour> entitys = ((SelectorArgumentValue)(ref selector)).GetEntitys(x.Source);
int num = 0;
foreach (NetworkBehaviour item in entitys)
{
if (!(item is PlayerControllerB))
{
try
{
DestroyEntity(item);
num++;
}
catch (Exception data)
{
Debug.LogError(data);
}
}
}
x.Source.SendCommandResult($"Destroyed {BFLCUtility.GetEntityName(entitys, num)}", true);
return num;
}
return 0;
})))));
}
public static void DestroyEntity(NetworkBehaviour entity)
{
NetworkObject val = default(NetworkObject);
if (!((Object)(object)NetworkManager.Singleton == (Object)null) && NetworkManager.Singleton.IsServer && !(entity is PlayerControllerB) && ((Component)entity).TryGetComponent<NetworkObject>(ref val))
{
val.Despawn(true);
}
}
}
public sealed class GameSpeedCommand : ServerCommand
{
public const string resultGetText = "The game speed is {0}";
public const string resultSetText = "Set the game speed to {0}";
private GameSpeedCommand()
{
}
public override void Register()
{
ServerCommand.dispatcher.Register((Func<IArgumentContext<ServerCommandSource>, LiteralArgumentBuilder<ServerCommandSource>>)((IArgumentContext<ServerCommandSource> x) => ((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "gamespeed")).Requires((Predicate<ServerCommandSource>)((ServerCommandSource x) => x.isOp))).Then<LiteralCommandNode<ServerCommandSource>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "get")).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
float gameSpeed = GetGameSpeed();
x.Source.SendCommandResult($"The game speed is {gameSpeed}", false);
return Mathf.RoundToInt(GetGameSpeed() * 100f);
})))).Then<LiteralCommandNode<ServerCommandSource>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "set")).Then<ArgumentCommandNode<ServerCommandSource, float>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, float>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, float>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, float>, ArgumentCommandNode<ServerCommandSource, float>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, float>(x, "timescale", (IArgumentType<float>)(object)Arguments.Float(0f, 100f))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
float @float = Arguments.GetFloat<ServerCommandSource>(x, "timescale");
SetGameSpeed(@float);
x.Source.SendCommandResult($"Set the game speed to {@float}", true);
return Mathf.RoundToInt(@float * 100f);
})))))));
}
public static float GetGameSpeed()
{
if ((Object)(object)NetworkManager.Singleton == (Object)null || !NetworkManager.Singleton.IsServer)
{
return 0f;
}
return Time.timeScale;
}
public static void SetGameSpeed(float timeScale)
{
if (!((Object)(object)NetworkManager.Singleton == (Object)null) && NetworkManager.Singleton.IsServer)
{
InternalSetGameSpeedClientRpc(timeScale);
}
}
[ClientRpc]
private static void InternalSetGameSpeedClientRpc(float timeScale)
{
Time.timeScale = timeScale;
}
}
[StaticNetcode]
public sealed class InvincibilityCommand : ServerCommand
{
public const string resultGetText = "Value of invincibility for player {0} is {1}";
public const string resultSetText = "Value for invincibility for player {0} set to {1}";
private static Dictionary<PlayerControllerB, bool> invincibilityList = new Dictionary<PlayerControllerB, bool>();
private InvincibilityCommand()
{
}
public override void Register()
{
ServerCommand.dispatcher.Register((Func<IArgumentContext<ServerCommandSource>, LiteralArgumentBuilder<ServerCommandSource>>)((IArgumentContext<ServerCommandSource> x) => ((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "invincibility")).Requires((Predicate<ServerCommandSource>)((ServerCommandSource x) => x.isOp))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
NetworkBehaviour sender = x.Source.sender;
PlayerControllerB val5 = (PlayerControllerB)(object)((sender is PlayerControllerB) ? sender : null);
if (val5 != null)
{
SetInvincibility(val5, value: true);
x.Source.SendCommandResult($"Value for invincibility for player {BFLCUtility.GetEntityName(x.Source.sender)} set to {true}", true);
return 1;
}
return 0;
})).Then<ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, SelectorArgumentValue>, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, SelectorArgumentValue>, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, SelectorArgumentValue>, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, SelectorArgumentValue>(x, "target", (IArgumentType<SelectorArgumentValue>)(object)LethalArguments.Selector(true, true))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
SelectorArgumentValue selector3 = LethalArguments.GetSelector<ServerCommandSource>(x, "target");
NetworkBehaviour val3 = ((SelectorArgumentValue)(ref selector3)).GetEntitys(x.Source).First();
PlayerControllerB val4 = (PlayerControllerB)(object)((val3 is PlayerControllerB) ? val3 : null);
if (val4 != null)
{
SetInvincibility(val4, value: true);
x.Source.SendCommandResult($"Value for invincibility for player {BFLCUtility.GetEntityName(val3)} set to {true}", true);
return 1;
}
return 0;
})).Then<LiteralCommandNode<ServerCommandSource>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "get")).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
CommandContext<ServerCommandSource> x2 = x;
SelectorArgumentValue selector2 = LethalArguments.GetSelector<ServerCommandSource>(x2, "target");
NetworkBehaviour target = ((SelectorArgumentValue)(ref selector2)).GetEntitys(x2.Source).First();
PlayerControllerB player = default(PlayerControllerB);
ref PlayerControllerB reference = ref player;
NetworkBehaviour obj = target;
reference = (PlayerControllerB)(object)((obj is PlayerControllerB) ? obj : null);
if (player != null)
{
Async();
return 1;
}
return 0;
async void Async()
{
bool? flag = await GetInvincibility(player);
x2.Source.SendCommandResult(string.Format("Value for invincibility for player {0} set to {1}", BFLCUtility.GetEntityName(target), flag?.ToString() ?? "timeout"), false);
}
})))).Then<LiteralCommandNode<ServerCommandSource>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "set")).Then<ArgumentCommandNode<ServerCommandSource, bool>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, bool>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, bool>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, bool>, ArgumentCommandNode<ServerCommandSource, bool>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, bool>(x, "value", (IArgumentType<bool>)(object)Arguments.Bool())).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
SelectorArgumentValue selector = LethalArguments.GetSelector<ServerCommandSource>(x, "target");
NetworkBehaviour val = ((SelectorArgumentValue)(ref selector)).GetEntitys(x.Source).First();
bool @bool = Arguments.GetBool<ServerCommandSource>(x, "value");
PlayerControllerB val2 = (PlayerControllerB)(object)((val is PlayerControllerB) ? val : null);
if (val2 != null)
{
SetInvincibility(val2, @bool);
x.Source.SendCommandResult($"Value for invincibility for player {BFLCUtility.GetEntityName(val)} set to {@bool}", true);
return 1;
}
return 0;
})))))))));
}
public static async Task<bool?> GetInvincibility(PlayerControllerB player)
{
if ((Object)(object)NetworkManager.Singleton == (Object)null || !NetworkManager.Singleton.IsServer)
{
return false;
}
if (invincibilityList.ContainsKey(player))
{
invincibilityList.Remove(player);
}
InternalGetInvincibilityClientRpc(RPCParamsUtility.ToRpc(player));
Stopwatch stopwatch = Stopwatch.StartNew();
while (!invincibilityList.ContainsKey(player))
{
if (stopwatch.ElapsedMilliseconds >= 3000)
{
return null;
}
await Task.Delay(1);
}
bool value = invincibilityList[player];
invincibilityList.Remove(player);
return value;
}
[ClientRpc]
private static void InternalGetInvincibilityClientRpc(ClientRpcParams rpcParams = default(ClientRpcParams))
{
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
InternalGetInvincibilityServerRpc(!StartOfRound.Instance.allowLocalPlayerDeath);
}
[ServerRpc]
private static void InternalGetInvincibilityServerRpc(bool value, ServerRpcParams rpcParams = default(ServerRpcParams))
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
PlayerControllerB key = default(PlayerControllerB);
if (RPCParamsUtility.TryGetPlayer(rpcParams, ref key))
{
invincibilityList[key] = value;
}
}
public static void SetInvincibility(PlayerControllerB player, bool value)
{
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)NetworkManager.Singleton == (Object)null) && NetworkManager.Singleton.IsServer)
{
InternalSetInvincibilityClientRpc(value, RPCParamsUtility.ToRpc(player));
}
}
[ClientRpc]
private static void InternalSetInvincibilityClientRpc(bool value, ClientRpcParams rpcParams = default(ClientRpcParams))
{
StartOfRound.Instance.allowLocalPlayerDeath = !value;
}
}
public sealed class KillCommand : ServerCommand
{
public const string resultText = "Killed {0}";
private KillCommand()
{
}
public override void Register()
{
ServerCommand.dispatcher.Register((Func<IArgumentContext<ServerCommandSource>, LiteralArgumentBuilder<ServerCommandSource>>)((IArgumentContext<ServerCommandSource> x) => ((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "kill")).Requires((Predicate<ServerCommandSource>)((ServerCommandSource x) => x.isOp))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
if ((Object)(object)x.Source.sender != (Object)null)
{
KillEntity(x.Source.sender);
x.Source.SendCommandResult($"Killed {BFLCUtility.GetEntityName(x.Source.sender)}", true);
return 1;
}
return 0;
})).Then<ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, SelectorArgumentValue>, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, SelectorArgumentValue>(x, "targets", (IArgumentType<SelectorArgumentValue>)(object)LethalArguments.Selector(false, false))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
SelectorArgumentValue selector = LethalArguments.GetSelector<ServerCommandSource>(x, "targets");
IEnumerable<NetworkBehaviour> entitys = ((SelectorArgumentValue)(ref selector)).GetEntitys(x.Source);
int num = 0;
foreach (NetworkBehaviour item in entitys)
{
if ((item is PlayerControllerB || item is EnemyAI) ? true : false)
{
try
{
KillEntity(item);
num++;
}
catch (Exception data)
{
Debug.LogError(data);
}
}
}
x.Source.SendCommandResult($"Killed {BFLCUtility.GetEntityName(entitys, num)}", true);
return num;
})))));
}
public static void KillEntity(NetworkBehaviour entity)
{
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)NetworkManager.Singleton == (Object)null) && NetworkManager.Singleton.IsServer && ((entity is PlayerControllerB || entity is EnemyAI) ? true : false))
{
InternalKillEntityClientRpc(NetworkBehaviourReference.op_Implicit(entity));
}
}
[ClientRpc]
private static void InternalKillEntityClientRpc(NetworkBehaviourReference entityRef)
{
//IL_0018: 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_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
NetworkBehaviour val = default(NetworkBehaviour);
if (!((NetworkBehaviourReference)(ref entityRef)).TryGet(ref val, (NetworkManager)null))
{
return;
}
PlayerControllerB val2 = (PlayerControllerB)(object)((val is PlayerControllerB) ? val : null);
if (val2 != null)
{
val2.KillPlayer(Vector3.up * 5f, true, (CauseOfDeath)0, 0, default(Vector3), false);
return;
}
EnemyAI val3 = (EnemyAI)(object)((val is EnemyAI) ? val : null);
if (val3 != null)
{
val3.KillEnemy(false);
}
}
}
[StaticNetcode]
public sealed class ReviveCommand : ServerCommand
{
public const string resultText = "Revived {0}";
private ReviveCommand()
{
}
public override void Register()
{
ServerCommand.dispatcher.Register((Func<IArgumentContext<ServerCommandSource>, LiteralArgumentBuilder<ServerCommandSource>>)((IArgumentContext<ServerCommandSource> x) => ((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "revive")).Requires((Predicate<ServerCommandSource>)((ServerCommandSource x) => x.isOp))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
NetworkBehaviour sender = x.Source.sender;
PlayerControllerB val2 = (PlayerControllerB)(object)((sender is PlayerControllerB) ? sender : null);
if (val2 != null)
{
RevivePlayer(val2);
x.Source.SendCommandResult($"Revived {BFLCUtility.GetEntityName(x.Source.sender)}", true);
return 1;
}
return 0;
})).Then<ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, SelectorArgumentValue>, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, SelectorArgumentValue>(x, "targets", (IArgumentType<SelectorArgumentValue>)(object)LethalArguments.Selector(true, false))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
SelectorArgumentValue selector = LethalArguments.GetSelector<ServerCommandSource>(x, "targets");
IEnumerable<NetworkBehaviour> entitys = ((SelectorArgumentValue)(ref selector)).GetEntitys(x.Source);
int num = 0;
foreach (NetworkBehaviour item in entitys)
{
PlayerControllerB val = (PlayerControllerB)(object)((item is PlayerControllerB) ? item : null);
if (val != null)
{
try
{
RevivePlayer(val);
num++;
}
catch (Exception data)
{
Debug.LogError(data);
}
}
}
x.Source.SendCommandResult($"Revived {BFLCUtility.GetEntityName(entitys, num)}", true);
return num;
})))));
}
public static void RevivePlayer(PlayerControllerB player)
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)NetworkManager.Singleton == (Object)null) && NetworkManager.Singleton.IsServer)
{
InternalRevivePlayerClientRpc(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)player));
}
}
[ClientRpc]
private static void InternalRevivePlayerClientRpc(NetworkBehaviourReference entityRef)
{
//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
//IL_0186: Unknown result type (might be due to invalid IL or missing references)
//IL_028e: Unknown result type (might be due to invalid IL or missing references)
//IL_0293: Unknown result type (might be due to invalid IL or missing references)
PlayerControllerB val = default(PlayerControllerB);
if (!((NetworkBehaviourReference)(ref entityRef)).TryGet<PlayerControllerB>(ref val, (NetworkManager)null) || !val.isPlayerDead)
{
return;
}
StartOfRound.Instance.allPlayersDead = false;
for (int i = 0; i < StartOfRound.Instance.allPlayerScripts.Length; i++)
{
if ((Object)(object)val != (Object)(object)StartOfRound.Instance.allPlayerScripts[i])
{
continue;
}
Debug.Log("Reviving players A");
val.ResetPlayerBloodObjects(val.isPlayerDead);
if (!val.isPlayerDead && !val.isPlayerControlled)
{
continue;
}
val.isClimbingLadder = false;
if (!val.inSpecialInteractAnimation || (Object)(object)val.currentTriggerInAnimationWith == (Object)null || !Object.op_Implicit((Object)(object)((Component)val.currentTriggerInAnimationWith).GetComponentInChildren<MoveToExitSpecialAnimation>()))
{
val.clampLooking = false;
((Component)val.gameplayCamera).transform.localEulerAngles = new Vector3(((Component)val.gameplayCamera).transform.localEulerAngles.x, 0f, ((Component)val.gameplayCamera).transform.localEulerAngles.z);
val.inVehicleAnimation = false;
}
val.overridePoisonValue = false;
val.disableMoveInput = false;
val.ResetZAndXRotation();
((Collider)val.thisController).enabled = true;
val.health = 100;
val.hasBeenCriticallyInjured = false;
val.disableLookInput = false;
val.disableInteract = false;
((Behaviour)val.nightVisionRadar).enabled = false;
Debug.Log("Reviving players B");
val.isPlayerDead = false;
val.enemyWaitingForBodyRagdoll = null;
val.isPlayerControlled = true;
val.isInElevator = true;
val.isInHangarShipRoom = true;
val.isInsideFactory = false;
val.parentedToElevatorLastFrame = false;
val.overrideGameOverSpectatePivot = null;
StartOfRound.Instance.SetPlayerObjectExtrapolate(false);
val.TeleportPlayer(StartOfRound.Instance.GetPlayerSpawnPosition(i, false), false, 0f, false, true);
val.setPositionOfDeadPlayer = false;
val.DisablePlayerModel(((Component)val).gameObject, true, true);
((Behaviour)val.helmetLight).enabled = false;
Debug.Log("Reviving players C");
val.Crouch(false);
val.criticallyInjured = false;
if ((Object)(object)val.playerBodyAnimator != (Object)null)
{
val.playerBodyAnimator.SetBool("Limp", false);
}
val.bleedingHeavily = false;
val.activatingItem = false;
val.twoHanded = false;
val.inShockingMinigame = false;
val.inSpecialInteractAnimation = false;
val.freeRotationInInteractAnimation = false;
val.disableSyncInAnimation = false;
val.inAnimationWithEnemy = null;
val.holdingWalkieTalkie = false;
val.speakingToWalkieTalkie = false;
Debug.Log("Reviving players D");
val.isSinking = false;
val.isUnderwater = false;
val.sinkingValue = 0f;
val.statusEffectAudio.Stop();
val.DisableJetpackControlsLocally();
val.health = 100;
Debug.Log("Reviving players E");
val.mapRadarDotAnimator.SetBool("dead", false);
val.externalForceAutoFade = Vector3.zero;
val.carryWeight = 1f;
if (((NetworkBehaviour)val).IsOwner)
{
HUDManager.Instance.SetCracksOnVisor(100f);
HUDManager.Instance.gasHelmetAnimator.SetBool("gasEmitting", false);
val.hasBegunSpectating = false;
HUDManager.Instance.RemoveSpectateUI();
HUDManager.Instance.gameOverAnimator.SetTrigger("revive");
val.hinderedMultiplier = 1f;
val.isMovementHindered = 0;
val.sourcesCausingSinking = 0;
StartOfRound.Instance.SendChangedWeightEvent();
Debug.Log("Reviving players E2");
val.reverbPreset = StartOfRound.Instance.shipReverb;
}
Debug.Log("Reviving players F");
HUDManager.Instance.spitOnCameraAlpha = 1f;
SoundManager.Instance.earsRingingTimer = 0f;
SoundManager.Instance.alternateEarsRinging = false;
HUDManager.Instance.cadaverFilter = 0f;
val.voiceMuffledByEnemy = false;
SoundManager.Instance.playerVoicePitchTargets[i] = 1f;
SoundManager.Instance.SetPlayerPitch(1f, i);
if ((Object)(object)val.currentVoiceChatIngameSettings == (Object)null)
{
StartOfRound.Instance.RefreshPlayerVoicePlaybackObjects();
}
if ((Object)(object)val.currentVoiceChatIngameSettings != (Object)null)
{
if ((Object)(object)val.currentVoiceChatIngameSettings.voiceAudio == (Object)null)
{
val.currentVoiceChatIngameSettings.InitializeComponents();
}
if ((Object)(object)val.currentVoiceChatIngameSettings.voiceAudio == (Object)null)
{
return;
}
((Component)val.currentVoiceChatIngameSettings.voiceAudio).GetComponent<OccludeAudio>().overridingLowPass = false;
}
Debug.Log("Reviving players G");
}
if ((Object)(object)val == (Object)(object)GameNetworkManager.Instance.localPlayerController)
{
val.bleedingHeavily = false;
val.criticallyInjured = false;
if ((Object)(object)val.playerBodyAnimator != (Object)null)
{
val.playerBodyAnimator.SetBool("Limp", false);
}
val.health = 100;
HUDManager.Instance.UpdateHealthUI(100, false);
val.spectatedPlayerScript = null;
((Behaviour)HUDManager.Instance.audioListenerLowPass).enabled = false;
Debug.Log("Reviving players H");
StartOfRound.Instance.SetSpectateCameraToGameOverMode(false, val);
StartOfRound.Instance.UpdatePlayerVoiceEffects();
StartOfRound.Instance.ResetMiscValues();
HUDManager.Instance.HideHUD(false);
}
StartOfRound instance = StartOfRound.Instance;
instance.livingPlayers++;
}
}
public sealed class SummonCommand : ServerCommand
{
[CompilerGenerated]
private sealed class <SummonEntityCoroutine>d__5 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public EnemyAI enemyAI;
public bool isOutside;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <SummonEntityCoroutine>d__5(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;
<>2__current = null;
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
enemyAI.SetEnemyOutside(isOutside);
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();
}
}
public const string resultText = "Summoned new {0}";
private SummonCommand()
{
}
public override void Register()
{
ServerCommand.dispatcher.Register((Func<IArgumentContext<ServerCommandSource>, LiteralArgumentBuilder<ServerCommandSource>>)((IArgumentContext<ServerCommandSource> x) => ((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "summon")).Requires((Predicate<ServerCommandSource>)((ServerCommandSource x) => x.isOp))).Then<LiteralCommandNode<ServerCommandSource>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "enemy")).Then<ArgumentCommandNode<ServerCommandSource, EnemyType>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, EnemyType>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, EnemyType>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, EnemyType>, ArgumentCommandNode<ServerCommandSource, EnemyType>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, EnemyType>, ArgumentCommandNode<ServerCommandSource, EnemyType>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, EnemyType>(x, "entity", (IArgumentType<EnemyType>)(object)LethalArguments.EnemyType())).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
EnemyType enemyType2 = LethalArguments.GetEnemyType<ServerCommandSource>(x, "entity");
SummonEntity(enemyType2, x.Source.position);
x.Source.SendCommandResult($"Summoned new {enemyType2.enemyName}", true);
return 1;
})).Then<ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, CoordinatesArgumentValue<float>[]>, ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, CoordinatesArgumentValue<float>[]>(x, "location", (IArgumentType<CoordinatesArgumentValue<float>[]>)(object)LethalArguments.Vector3((float?)null, (float?)null, true))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
EnemyType enemyType = LethalArguments.GetEnemyType<ServerCommandSource>(x, "entity");
Vector3 vector4 = LethalArguments.GetVector3<ServerCommandSource>(x, "location");
SummonEntity(enemyType, vector4);
x.Source.SendCommandResult($"Summoned new {enemyType.enemyName}", true);
return 1;
})))))))).Then<LiteralCommandNode<ServerCommandSource>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "anomaly")).Then<ArgumentCommandNode<ServerCommandSource, AnomalyType>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, AnomalyType>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, AnomalyType>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, AnomalyType>, ArgumentCommandNode<ServerCommandSource, AnomalyType>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, AnomalyType>, ArgumentCommandNode<ServerCommandSource, AnomalyType>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, AnomalyType>(x, "entity", (IArgumentType<AnomalyType>)(object)LethalArguments.AnomalyType())).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
AnomalyType anomalyType2 = LethalArguments.GetAnomalyType<ServerCommandSource>(x, "entity");
SummonEntity(anomalyType2, x.Source.position);
x.Source.SendCommandResult($"Summoned new {anomalyType2.anomalyName}", true);
return 1;
})).Then<ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, CoordinatesArgumentValue<float>[]>, ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, CoordinatesArgumentValue<float>[]>(x, "location", (IArgumentType<CoordinatesArgumentValue<float>[]>)(object)LethalArguments.Vector3((float?)null, (float?)null, true))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
AnomalyType anomalyType = LethalArguments.GetAnomalyType<ServerCommandSource>(x, "entity");
Vector3 vector3 = LethalArguments.GetVector3<ServerCommandSource>(x, "location");
SummonEntity(anomalyType, vector3);
x.Source.SendCommandResult($"Summoned new {anomalyType.anomalyName}", true);
return 1;
})))))))).Then<LiteralCommandNode<ServerCommandSource>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "item")).Then<ArgumentCommandNode<ServerCommandSource, Item>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, Item>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, Item>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, Item>, ArgumentCommandNode<ServerCommandSource, Item>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, Item>, ArgumentCommandNode<ServerCommandSource, Item>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, Item>, ArgumentCommandNode<ServerCommandSource, Item>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, Item>(x, "item", (IArgumentType<Item>)(object)LethalArguments.ItemType())).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
Item itemType4 = LethalArguments.GetItemType<ServerCommandSource>(x, "item");
SummonEntity(itemType4, x.Source.position);
x.Source.SendCommandResult($"Summoned new {itemType4.itemName}", true);
return 1;
})).Then<ArgumentCommandNode<ServerCommandSource, int>>((IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, int>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, int>, ArgumentCommandNode<ServerCommandSource, int>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, int>(x, "price", (IArgumentType<int>)(object)Arguments.Integer(int.MinValue, int.MaxValue))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
Item itemType3 = LethalArguments.GetItemType<ServerCommandSource>(x, "item");
int integer2 = Arguments.GetInteger<ServerCommandSource>(x, "price");
SummonEntity(itemType3, x.Source.position, integer2);
x.Source.SendCommandResult($"Summoned new {itemType3.itemName}", true);
return 1;
}))).Then<ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, CoordinatesArgumentValue<float>[]>, ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, CoordinatesArgumentValue<float>[]>, ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, CoordinatesArgumentValue<float>[]>(x, "location", (IArgumentType<CoordinatesArgumentValue<float>[]>)(object)LethalArguments.Vector3((float?)null, (float?)null, true))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
Item itemType2 = LethalArguments.GetItemType<ServerCommandSource>(x, "item");
Vector3 vector2 = LethalArguments.GetVector3<ServerCommandSource>(x, "location");
SummonEntity(itemType2, vector2);
x.Source.SendCommandResult($"Summoned new {itemType2.itemName}", true);
return 1;
})).Then<ArgumentCommandNode<ServerCommandSource, int>>((IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, int>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, int>, ArgumentCommandNode<ServerCommandSource, int>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, int>(x, "price", (IArgumentType<int>)(object)Arguments.Integer(int.MinValue, int.MaxValue))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
Item itemType = LethalArguments.GetItemType<ServerCommandSource>(x, "item");
Vector3 vector = LethalArguments.GetVector3<ServerCommandSource>(x, "location");
int integer = Arguments.GetInteger<ServerCommandSource>(x, "price");
SummonEntity(itemType, vector, integer);
x.Source.SendCommandResult($"Summoned new {itemType.itemName}", true);
return 1;
}))))))))));
}
public static void SummonEntity(EnemyType entityType, Vector3 position)
{
//IL_001f: 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_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: 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)
if (!((Object)(object)NetworkManager.Singleton == (Object)null) && NetworkManager.Singleton.IsServer)
{
NetworkObjectReference val = RoundManager.Instance.SpawnEnemyGameObject(position, 0f, 0, entityType);
NetworkObject val2 = default(NetworkObject);
if (((NetworkObjectReference)(ref val)).TryGet(ref val2, (NetworkManager)null))
{
entityType.numberSpawned++;
entityType.hasSpawnedAtLeastOne = true;
bool isOutside = ((Component)val2).transform.position.y >= -100f;
EnemyAI component = ((Component)val2).GetComponent<EnemyAI>();
((MonoBehaviour)component).StartCoroutine(SummonEntityCoroutine(component, isOutside));
InternalSummonEnemyClientRpc(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)component), isOutside);
}
}
}
[ClientRpc]
private static void InternalSummonEnemyClientRpc(NetworkBehaviourReference entityRef, bool isOutside)
{
EnemyAI val = default(EnemyAI);
if (((NetworkBehaviourReference)(ref entityRef)).TryGet<EnemyAI>(ref val, (NetworkManager)null))
{
((MonoBehaviour)val).StartCoroutine(SummonEntityCoroutine(val, isOutside));
}
}
[IteratorStateMachine(typeof(<SummonEntityCoroutine>d__5))]
private static IEnumerator SummonEntityCoroutine(EnemyAI enemyAI, bool isOutside)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <SummonEntityCoroutine>d__5(0)
{
enemyAI = enemyAI,
isOutside = isOutside
};
}
public static void SummonEntity(AnomalyType entityType, Vector3 position)
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)NetworkManager.Singleton == (Object)null) && NetworkManager.Singleton.IsServer)
{
GameObject obj = Object.Instantiate<GameObject>(entityType.anomalyPrefab, position, Quaternion.identity);
obj.GetComponentInChildren<NetworkObject>().Spawn(true);
Anomaly component = obj.GetComponent<Anomaly>();
RoundManager.Instance.SpawnedAnomalies.Add(component);
}
}
public static void SummonEntity(Item entityType, Vector3 position, int price = 0)
{
//IL_0020: 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_003d: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)NetworkManager.Singleton == (Object)null) && NetworkManager.Singleton.IsServer)
{
NetworkObject component = Object.Instantiate<GameObject>(entityType.spawnPrefab, position, Quaternion.Euler(entityType.restingRotation)).GetComponent<NetworkObject>();
component.Spawn(true);
InternalSummonItemClientRpc(NetworkObjectReference.op_Implicit(component), price);
}
}
[ClientRpc]
private static void InternalSummonItemClientRpc(NetworkObjectReference entityRef, int price)
{
NetworkObject val = default(NetworkObject);
if (((NetworkObjectReference)(ref entityRef)).TryGet(ref val, (NetworkManager)null))
{
GrabbableObject component = ((Component)val).gameObject.GetComponent<GrabbableObject>();
if ((Object)(object)((Component)component).GetComponentInChildren<ScanNodeProperties>() != (Object)null)
{
component.SetScrapValue(price);
}
}
}
}
[StaticNetcode]
public sealed class TeleportCommand : ServerCommand
{
public const string resultEntityText = "Teleported {0} to {1}";
public const string resultLocationText = "Teleported {0} to {1}, {2}, {3}";
private TeleportCommand()
{
}
public override void Register()
{
LiteralCommandNode<ServerCommandSource> node = ServerCommand.dispatcher.Register((Func<IArgumentContext<ServerCommandSource>, LiteralArgumentBuilder<ServerCommandSource>>)((IArgumentContext<ServerCommandSource> x) => ((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "teleport")).Requires((Predicate<ServerCommandSource>)((ServerCommandSource x) => x.isOp))).Then<ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, CoordinatesArgumentValue<float>[]>, ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, CoordinatesArgumentValue<float>[]>(x, "location", (IArgumentType<CoordinatesArgumentValue<float>[]>)(object)LethalArguments.Vector3((float?)null, (float?)null, true))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_0072: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)x.Source.sender != (Object)null)
{
Vector3 vector2 = LethalArguments.GetVector3<ServerCommandSource>(x, "location");
TeleportEntity(x.Source.sender, vector2);
x.Source.SendCommandResult($"Teleported {BFLCUtility.GetEntityName(x.Source.sender)} to {vector2.x}, {vector2.y}, {vector2.z}", true);
return 1;
}
return 0;
})))).Then<ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, SelectorArgumentValue>, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, SelectorArgumentValue>(x, "destination", (IArgumentType<SelectorArgumentValue>)(object)LethalArguments.Selector(false, true))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: 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)
if ((Object)(object)x.Source.sender != (Object)null)
{
SelectorArgumentValue selector3 = LethalArguments.GetSelector<ServerCommandSource>(x, "destination");
IEnumerable<NetworkBehaviour> entitys4 = ((SelectorArgumentValue)(ref selector3)).GetEntitys(x.Source);
if (LinqExtras.CountIsOne<NetworkBehaviour>(entitys4))
{
TeleportEntity(x.Source.sender, ((Component)entitys4.First()).transform.position);
x.Source.SendCommandResult($"Teleported {BFLCUtility.GetEntityName(x.Source.sender)} to {BFLCUtility.GetEntityName(entitys4, -1)}", true);
return 1;
}
}
return 0;
})))).Then<ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, SelectorArgumentValue>, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, SelectorArgumentValue>, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, SelectorArgumentValue>(x, "targets", (IArgumentType<SelectorArgumentValue>)(object)LethalArguments.Selector(false, false))).Then<ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, CoordinatesArgumentValue<float>[]>, ArgumentCommandNode<ServerCommandSource, CoordinatesArgumentValue<float>[]>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, CoordinatesArgumentValue<float>[]>(x, "location", (IArgumentType<CoordinatesArgumentValue<float>[]>)(object)LethalArguments.Vector3((float?)null, (float?)null, true))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: 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_0077: Unknown result type (might be due to invalid IL or missing references)
//IL_0085: Unknown result type (might be due to invalid IL or missing references)
//IL_0093: Unknown result type (might be due to invalid IL or missing references)
SelectorArgumentValue selector2 = LethalArguments.GetSelector<ServerCommandSource>(x, "targets");
IEnumerable<NetworkBehaviour> entitys3 = ((SelectorArgumentValue)(ref selector2)).GetEntitys(x.Source);
Vector3 vector = LethalArguments.GetVector3<ServerCommandSource>(x, "location");
int num2 = 0;
foreach (NetworkBehaviour item in entitys3)
{
TeleportEntity(item, vector);
num2++;
}
x.Source.SendCommandResult($"Teleported {BFLCUtility.GetEntityName(entitys3, num2)} to {vector.x}, {vector.y}, {vector.z}", true);
return num2;
})))).Then<ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, SelectorArgumentValue>, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, SelectorArgumentValue>(x, "destination", (IArgumentType<SelectorArgumentValue>)(object)LethalArguments.Selector(false, true))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: 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)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
SelectorArgumentValue selector = LethalArguments.GetSelector<ServerCommandSource>(x, "targets");
IEnumerable<NetworkBehaviour> entitys = ((SelectorArgumentValue)(ref selector)).GetEntitys(x.Source);
selector = LethalArguments.GetSelector<ServerCommandSource>(x, "destination");
IEnumerable<NetworkBehaviour> entitys2 = ((SelectorArgumentValue)(ref selector)).GetEntitys(x.Source);
if (LinqExtras.CountIsOne<NetworkBehaviour>(entitys2))
{
Vector3 position = ((Component)entitys2.First()).transform.position;
int num = 0;
foreach (NetworkBehaviour item2 in entitys)
{
TeleportEntity(item2, position);
num++;
}
x.Source.SendCommandResult($"Teleported {BFLCUtility.GetEntityName(entitys, -1)} to {BFLCUtility.GetEntityName(entitys2, -1)}", true);
return num;
}
return 0;
})))))));
ServerCommand.dispatcher.Register((Func<IArgumentContext<ServerCommandSource>, LiteralArgumentBuilder<ServerCommandSource>>)((IArgumentContext<ServerCommandSource> x) => ((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "tp")).Requires((Predicate<ServerCommandSource>)((ServerCommandSource x) => x.isOp))).Redirect((CommandNode<ServerCommandSource>)(object)node)));
}
public static void TeleportEntity(NetworkBehaviour entity, Vector3 position)
{
//IL_002b: 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_006c: 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)
//IL_0078: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)NetworkManager.Singleton == (Object)null || !NetworkManager.Singleton.IsServer)
{
return;
}
EnemyAI val = (EnemyAI)(object)((entity is EnemyAI) ? entity : null);
if (val != null)
{
val.SetEnemyOutside(((Component)val).transform.position.y >= -100f);
val.agent.Warp(position);
}
else
{
GrabbableObject val2 = (GrabbableObject)(object)((entity is GrabbableObject) ? entity : null);
if (val2 != null)
{
val2.FallToGround(false, false, position);
}
}
((Component)entity).transform.position = position;
InternalTeleportEntityClientRpc(NetworkBehaviourReference.op_Implicit(entity), position);
}
[ClientRpc]
private static void InternalTeleportEntityClientRpc(NetworkBehaviourReference entityRef, Vector3 position)
{
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
NetworkBehaviour val = default(NetworkBehaviour);
if (!((NetworkBehaviourReference)(ref entityRef)).TryGet(ref val, (NetworkManager)null))
{
return;
}
EnemyAI val2 = (EnemyAI)(object)((val is EnemyAI) ? val : null);
if (val2 != null)
{
val2.SetEnemyOutside(((Component)val2).transform.position.y >= -100f);
val2.agent.Warp(position);
}
else
{
GrabbableObject val3 = (GrabbableObject)(object)((val is GrabbableObject) ? val : null);
if (val3 != null)
{
val3.FallToGround(false, false, position);
}
}
((Component)val).transform.position = position;
}
}
public sealed class TellrawCommand : ServerCommand
{
private TellrawCommand()
{
}
public override void Register()
{
ServerCommand.dispatcher.Register((Func<IArgumentContext<ServerCommandSource>, LiteralArgumentBuilder<ServerCommandSource>>)((IArgumentContext<ServerCommandSource> x) => ((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "tellraw")).Requires((Predicate<ServerCommandSource>)((ServerCommandSource x) => x.isOp))).Then<ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, SelectorArgumentValue>, ArgumentCommandNode<ServerCommandSource, SelectorArgumentValue>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, SelectorArgumentValue>(x, "targets", (IArgumentType<SelectorArgumentValue>)(object)LethalArguments.Selector(true, false))).Then<ArgumentCommandNode<ServerCommandSource, string>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, string>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, string>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, string>, ArgumentCommandNode<ServerCommandSource, string>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, string>(x, "message", (IArgumentType<string>)(object)Arguments.GreedyString())).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
SelectorArgumentValue selector = LethalArguments.GetSelector<ServerCommandSource>(x, "targets");
IEnumerable<NetworkBehaviour> entitys = ((SelectorArgumentValue)(ref selector)).GetEntitys(x.Source);
string @string = Arguments.GetString<ServerCommandSource>(x, "message");
int result = 0;
foreach (NetworkBehaviour item in entitys)
{
PlayerControllerB val = (PlayerControllerB)(object)((item is PlayerControllerB) ? item : null);
if (val != null)
{
BFLCUtility.SendChat(@string, val);
}
}
return result;
})))))));
}
}
public sealed class TimeCommand : ServerCommand
{
public const string resultGetText = "The time is {0}:{1:00} ({2})";
public const string resultSetText = "Set the time to {0}:{1:00} ({2})";
public const string resultSpeedGetText = "The time speed is {0}";
public const string resultSpeedSetText = "Set the time speed to {0}";
private TimeCommand()
{
}
public override void Register()
{
ServerCommand.dispatcher.Register((Func<IArgumentContext<ServerCommandSource>, LiteralArgumentBuilder<ServerCommandSource>>)((IArgumentContext<ServerCommandSource> x) => ((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "time")).Requires((Predicate<ServerCommandSource>)((ServerCommandSource x) => x.isOp))).Then<LiteralCommandNode<ServerCommandSource>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "get")).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
float timeHour = GetTimeHour();
int num3 = Mathf.FloorToInt(timeHour);
int num4 = (int)((timeHour - (float)num3) * 60f);
x.Source.SendCommandResult($"The time is {num3}:{num4:00} ({timeHour})", false);
return num3;
})))).Then<LiteralCommandNode<ServerCommandSource>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "set")).Then<ArgumentCommandNode<ServerCommandSource, float>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, float>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, float>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, float>, ArgumentCommandNode<ServerCommandSource, float>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, float>(x, "time", (IArgumentType<float>)(object)Arguments.Float(6f, 24f))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
float float2 = Arguments.GetFloat<ServerCommandSource>(x, "time");
SetTimeHour(float2);
int num = Mathf.FloorToInt(float2);
int num2 = (int)((float2 - (float)num) * 60f);
x.Source.SendCommandResult($"Set the time to {num}:{num2:00} ({float2})", true);
return num;
})))))).Then<LiteralCommandNode<ServerCommandSource>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)((ArgumentBuilder<ServerCommandSource, LiteralArgumentBuilder<ServerCommandSource>, LiteralCommandNode<ServerCommandSource>>)(object)LiteralArgumentBuilderExtensions.Literal<ServerCommandSource>(x, "speed")).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
float timeSpeed = GetTimeSpeed();
x.Source.SendCommandResult($"The time speed is {timeSpeed}", false);
return Mathf.FloorToInt(timeSpeed);
})).Then<ArgumentCommandNode<ServerCommandSource, float>>((Func<IArgumentContext<ServerCommandSource>, IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, float>>>)((IArgumentContext<ServerCommandSource> x) => (IArgumentBuilder<ServerCommandSource, ArgumentCommandNode<ServerCommandSource, float>>)(object)((ArgumentBuilder<ServerCommandSource, RequiredArgumentBuilder<ServerCommandSource, float>, ArgumentCommandNode<ServerCommandSource, float>>)(object)RequiredArgumentBuilderExtensions.Argument<ServerCommandSource, float>(x, "speed", (IArgumentType<float>)(object)Arguments.Float(float.MinValue, float.MaxValue))).Executes((Command<ServerCommandSource>)delegate(CommandContext<ServerCommandSource> x)
{
float @float = Arguments.GetFloat<ServerCommandSource>(x, "speed");
SetTimeSpeed(@float);
x.Source.SendCommandResult($"Set the time speed to {@float.ToString()}", true);
return Mathf.FloorToInt(@float);
})))))));
}
public static float GetTimeHour()
{
if ((Object)(object)NetworkManager.Singleton == (Object)null || !NetworkManager.Singleton.IsServer)
{
return 0f;
}
TimeOfDay instance = TimeOfDay.Instance;
SelectableLevel currentLevel = instance.currentLevel;
return instance.globalTime * currentLevel.DaySpeedMultiplier / instance.lengthOfHours + 6f;
}
public static void SetTimeHour(float time)
{
if (!((Object)(object)NetworkManager.Singleton == (Object)null) && NetworkManager.Singleton.IsServer)
{
InternalSetTimeHourClientRpc(time);
}
}
[ClientRpc]
private static void InternalSetTimeHourClientRpc(float time)
{
TimeOfDay instance = TimeOfDay.Instance;
SelectableLevel currentLevel = instance.currentLevel;
float num = (instance.globalTime = (time - 6f) / currentLevel.DaySpeedMultiplier * instance.lengthOfHours);
instance.currentDayTime = instance.CalculatePlanetTime(currentLevel);
instance.hour = (int)(instance.currentDayTime / instance.lengthOfHours);
instance.previousHour = instance.hour;
instance.globalTimeAtEndOfDay = num + (instance.totalTime - instance.currentDayTime) / currentLevel.DaySpeedMultiplier;
instance.normalizedTimeOfDay = instance.currentDayTime / instance.totalTime;
instance.RefreshClockUI();
}
public static float GetTimeSpeed()
{
return TimeOfDay.Instance.globalTimeSpeedMultiplier;
}
public static void SetTimeSpeed(float speed)
{
if (!((Object)(object)NetworkManager.Singleton == (Object)null) && NetworkManager.Singleton.IsServer)
{
InternalSetTimeSpeedClientRpc(speed);
}
}
[ClientRpc]
private static void InternalSetTimeSpeedClientRpc(float speed)
{
TimeOfDay.Instance.globalTimeSpeedMultiplier = speed;
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
