using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Unity.IL2CPP;
using BepInEx.Unity.IL2CPP.Utils;
using CodeStage.AntiCheat.ObscuredTypes;
using ExitGames.Client.Photon;
using HarmonyLib;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Photon.Pun;
using Photon.Realtime;
using PlayFab;
using PlayFab.ClientModels;
using PlayFab.Internal;
using SimpleJSON;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using UnityStandardAssets.Characters.FirstPerson;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("GoreBoxCheat")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("GoreBoxCheat")]
[assembly: AssemblyCopyright("Copyright © 2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("c6b7cac7-e50e-4f6a-a6d0-3d683ede969c")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
public static class ReflectionHelper
{
public static T FindVariableByType<T>(object instance)
{
if (instance == null)
{
throw new ArgumentNullException("instance", "Instance cannot be null.");
}
Type type = instance.GetType();
FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
FieldInfo[] array = fields;
foreach (FieldInfo fieldInfo in array)
{
if (fieldInfo.FieldType == typeof(T))
{
return (T)fieldInfo.GetValue(instance);
}
}
PropertyInfo[] properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
PropertyInfo[] array2 = properties;
foreach (PropertyInfo propertyInfo in array2)
{
if (propertyInfo.PropertyType == typeof(T) && propertyInfo.GetGetMethod(nonPublic: true) != null)
{
return (T)propertyInfo.GetValue(instance);
}
}
return default(T);
}
}
public class UsernameGenerator
{
public string GenerateName(int len)
{
if (len < 3)
{
throw new ArgumentException("Length must be at least 3 characters.");
}
Random random = new Random();
string[] array = new string[23]
{
"b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
"n", "p", "q", "r", "s", "t", "v", "w", "x", "z",
"ch", "sh", "th"
};
string[] array2 = new string[13]
{
"a", "e", "i", "o", "u", "ae", "ai", "oo", "ea", "ei",
"io", "ua", "ie"
};
string[] array3 = new string[6] { "_", ".", "-", "x", "z", "" };
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append(UpperFirst(array[random.Next(array.Length)]));
bool flag = true;
while (stringBuilder.Length < len - 1)
{
if (flag)
{
stringBuilder.Append(array2[random.Next(array2.Length)]);
}
else
{
stringBuilder.Append(array[random.Next(array.Length)]);
}
flag = !flag;
}
if (random.Next(100) < 50)
{
stringBuilder.Append(array3[random.Next(array3.Length)]);
}
else
{
stringBuilder.Append(random.Next(0, 10));
}
return stringBuilder.ToString();
}
private string UpperFirst(string input)
{
if (string.IsNullOrEmpty(input))
{
return input;
}
return char.ToUpper(input[0]) + input.Substring(1);
}
}
namespace SimpleJSON
{
public enum JSONNodeType
{
Array = 1,
Object = 2,
String = 3,
Number = 4,
NullValue = 5,
Boolean = 6,
None = 7,
Custom = 255
}
public enum JSONTextMode
{
Compact,
Indent
}
public abstract class JSONNode
{
public struct Enumerator
{
private enum Type
{
None,
Array,
Object
}
private Type type;
private Dictionary<string, JSONNode>.Enumerator m_Object;
private List<JSONNode>.Enumerator m_Array;
public bool IsValid => type != Type.None;
public KeyValuePair<string, JSONNode> Current
{
get
{
if (type == Type.Array)
{
return new KeyValuePair<string, JSONNode>(string.Empty, m_Array.Current);
}
if (type == Type.Object)
{
return m_Object.Current;
}
return new KeyValuePair<string, JSONNode>(string.Empty, null);
}
}
public Enumerator(List<JSONNode>.Enumerator aArrayEnum)
{
type = Type.Array;
m_Object = default(Dictionary<string, JSONNode>.Enumerator);
m_Array = aArrayEnum;
}
public Enumerator(Dictionary<string, JSONNode>.Enumerator aDictEnum)
{
type = Type.Object;
m_Object = aDictEnum;
m_Array = default(List<JSONNode>.Enumerator);
}
public bool MoveNext()
{
if (type == Type.Array)
{
return m_Array.MoveNext();
}
if (type == Type.Object)
{
return m_Object.MoveNext();
}
return false;
}
}
public struct ValueEnumerator
{
private Enumerator m_Enumerator;
public JSONNode Current => m_Enumerator.Current.Value;
public ValueEnumerator(List<JSONNode>.Enumerator aArrayEnum)
: this(new Enumerator(aArrayEnum))
{
}
public ValueEnumerator(Dictionary<string, JSONNode>.Enumerator aDictEnum)
: this(new Enumerator(aDictEnum))
{
}
public ValueEnumerator(Enumerator aEnumerator)
{
m_Enumerator = aEnumerator;
}
public bool MoveNext()
{
return m_Enumerator.MoveNext();
}
public ValueEnumerator GetEnumerator()
{
return this;
}
}
public struct KeyEnumerator
{
private Enumerator m_Enumerator;
public string Current => m_Enumerator.Current.Key;
public KeyEnumerator(List<JSONNode>.Enumerator aArrayEnum)
: this(new Enumerator(aArrayEnum))
{
}
public KeyEnumerator(Dictionary<string, JSONNode>.Enumerator aDictEnum)
: this(new Enumerator(aDictEnum))
{
}
public KeyEnumerator(Enumerator aEnumerator)
{
m_Enumerator = aEnumerator;
}
public bool MoveNext()
{
return m_Enumerator.MoveNext();
}
public KeyEnumerator GetEnumerator()
{
return this;
}
}
public class LinqEnumerator : IEnumerator<KeyValuePair<string, JSONNode>>, IDisposable, IEnumerator, IEnumerable<KeyValuePair<string, JSONNode>>, IEnumerable
{
private JSONNode m_Node;
private Enumerator m_Enumerator;
public KeyValuePair<string, JSONNode> Current => m_Enumerator.Current;
object IEnumerator.Current => m_Enumerator.Current;
internal LinqEnumerator(JSONNode aNode)
{
m_Node = aNode;
if (m_Node != null)
{
m_Enumerator = m_Node.GetEnumerator();
}
}
public bool MoveNext()
{
return m_Enumerator.MoveNext();
}
public void Dispose()
{
m_Node = null;
m_Enumerator = default(Enumerator);
}
public IEnumerator<KeyValuePair<string, JSONNode>> GetEnumerator()
{
return new LinqEnumerator(m_Node);
}
public void Reset()
{
if (m_Node != null)
{
m_Enumerator = m_Node.GetEnumerator();
}
}
IEnumerator IEnumerable.GetEnumerator()
{
return new LinqEnumerator(m_Node);
}
}
public static bool forceASCII = false;
public static bool longAsString = false;
public static bool allowLineComments = true;
[ThreadStatic]
private static StringBuilder m_EscapeBuilder;
public abstract JSONNodeType Tag { get; }
public virtual JSONNode this[int aIndex]
{
get
{
return null;
}
set
{
}
}
public virtual JSONNode this[string aKey]
{
get
{
return null;
}
set
{
}
}
public virtual string Value
{
get
{
return "";
}
set
{
}
}
public virtual int Count => 0;
public virtual bool IsNumber => false;
public virtual bool IsString => false;
public virtual bool IsBoolean => false;
public virtual bool IsNull => false;
public virtual bool IsArray => false;
public virtual bool IsObject => false;
public virtual bool Inline
{
get
{
return false;
}
set
{
}
}
public virtual IEnumerable<JSONNode> Children
{
get
{
yield break;
}
}
public IEnumerable<JSONNode> DeepChildren
{
get
{
foreach (JSONNode C in Children)
{
foreach (JSONNode deepChild in C.DeepChildren)
{
yield return deepChild;
}
}
}
}
public IEnumerable<KeyValuePair<string, JSONNode>> Linq => new LinqEnumerator(this);
public KeyEnumerator Keys => new KeyEnumerator(GetEnumerator());
public ValueEnumerator Values => new ValueEnumerator(GetEnumerator());
public virtual double AsDouble
{
get
{
double result = 0.0;
if (double.TryParse(Value, NumberStyles.Float, CultureInfo.InvariantCulture, out result))
{
return result;
}
return 0.0;
}
set
{
Value = value.ToString(CultureInfo.InvariantCulture);
}
}
public virtual int AsInt
{
get
{
return (int)AsDouble;
}
set
{
AsDouble = value;
}
}
public virtual float AsFloat
{
get
{
return (float)AsDouble;
}
set
{
AsDouble = value;
}
}
public virtual bool AsBool
{
get
{
bool result = false;
if (bool.TryParse(Value, out result))
{
return result;
}
return !string.IsNullOrEmpty(Value);
}
set
{
Value = (value ? "true" : "false");
}
}
public virtual long AsLong
{
get
{
long result = 0L;
if (long.TryParse(Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out result))
{
return result;
}
return 0L;
}
set
{
Value = value.ToString(CultureInfo.InvariantCulture);
}
}
public virtual ulong AsULong
{
get
{
ulong result = 0uL;
if (ulong.TryParse(Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out result))
{
return result;
}
return 0uL;
}
set
{
Value = value.ToString(CultureInfo.InvariantCulture);
}
}
public virtual JSONArray AsArray => this as JSONArray;
public virtual JSONObject AsObject => this as JSONObject;
internal static StringBuilder EscapeBuilder
{
get
{
if (m_EscapeBuilder == null)
{
m_EscapeBuilder = new StringBuilder();
}
return m_EscapeBuilder;
}
}
public virtual void Add(string aKey, JSONNode aItem)
{
}
public virtual void Add(JSONNode aItem)
{
Add("", aItem);
}
public virtual JSONNode Remove(string aKey)
{
return null;
}
public virtual JSONNode Remove(int aIndex)
{
return null;
}
public virtual JSONNode Remove(JSONNode aNode)
{
return aNode;
}
public virtual void Clear()
{
}
public virtual JSONNode Clone()
{
return null;
}
public virtual bool HasKey(string aKey)
{
return false;
}
public virtual JSONNode GetValueOrDefault(string aKey, JSONNode aDefault)
{
return aDefault;
}
public override string ToString()
{
StringBuilder stringBuilder = new StringBuilder();
WriteToStringBuilder(stringBuilder, 0, 0, JSONTextMode.Compact);
return stringBuilder.ToString();
}
public virtual string ToString(int aIndent)
{
StringBuilder stringBuilder = new StringBuilder();
WriteToStringBuilder(stringBuilder, 0, aIndent, JSONTextMode.Indent);
return stringBuilder.ToString();
}
internal abstract void WriteToStringBuilder(StringBuilder aSB, int aIndent, int aIndentInc, JSONTextMode aMode);
public abstract Enumerator GetEnumerator();
public static implicit operator JSONNode(string s)
{
return (s == null) ? ((JSONNode)JSONNull.CreateOrGet()) : ((JSONNode)new JSONString(s));
}
public static implicit operator string(JSONNode d)
{
return (d == null) ? null : d.Value;
}
public static implicit operator JSONNode(double n)
{
return new JSONNumber(n);
}
public static implicit operator double(JSONNode d)
{
return (d == null) ? 0.0 : d.AsDouble;
}
public static implicit operator JSONNode(float n)
{
return new JSONNumber(n);
}
public static implicit operator float(JSONNode d)
{
return (d == null) ? 0f : d.AsFloat;
}
public static implicit operator JSONNode(int n)
{
return new JSONNumber(n);
}
public static implicit operator int(JSONNode d)
{
return (!(d == null)) ? d.AsInt : 0;
}
public static implicit operator JSONNode(long n)
{
if (longAsString)
{
return new JSONString(n.ToString(CultureInfo.InvariantCulture));
}
return new JSONNumber(n);
}
public static implicit operator long(JSONNode d)
{
return (d == null) ? 0 : d.AsLong;
}
public static implicit operator JSONNode(ulong n)
{
if (longAsString)
{
return new JSONString(n.ToString(CultureInfo.InvariantCulture));
}
return new JSONNumber(n);
}
public static implicit operator ulong(JSONNode d)
{
return (d == null) ? 0 : d.AsULong;
}
public static implicit operator JSONNode(bool b)
{
return new JSONBool(b);
}
public static implicit operator bool(JSONNode d)
{
return !(d == null) && d.AsBool;
}
public static implicit operator JSONNode(KeyValuePair<string, JSONNode> aKeyValue)
{
return aKeyValue.Value;
}
public static bool operator ==(JSONNode a, object b)
{
if ((object)a == b)
{
return true;
}
bool flag = a is JSONNull || (object)a == null || a is JSONLazyCreator;
bool flag2 = b is JSONNull || b == null || b is JSONLazyCreator;
if (flag && flag2)
{
return true;
}
return !flag && a.Equals(b);
}
public static bool operator !=(JSONNode a, object b)
{
return !(a == b);
}
public override bool Equals(object obj)
{
return (object)this == obj;
}
public override int GetHashCode()
{
return base.GetHashCode();
}
internal static string Escape(string aText)
{
StringBuilder escapeBuilder = EscapeBuilder;
escapeBuilder.Length = 0;
if (escapeBuilder.Capacity < aText.Length + aText.Length / 10)
{
escapeBuilder.Capacity = aText.Length + aText.Length / 10;
}
foreach (char c in aText)
{
switch (c)
{
case '\\':
escapeBuilder.Append("\\\\");
continue;
case '"':
escapeBuilder.Append("\\\"");
continue;
case '\n':
escapeBuilder.Append("\\n");
continue;
case '\r':
escapeBuilder.Append("\\r");
continue;
case '\t':
escapeBuilder.Append("\\t");
continue;
case '\b':
escapeBuilder.Append("\\b");
continue;
case '\f':
escapeBuilder.Append("\\f");
continue;
}
if (c < ' ' || (forceASCII && c > '\u007f'))
{
ushort num = c;
escapeBuilder.Append("\\u").Append(num.ToString("X4"));
}
else
{
escapeBuilder.Append(c);
}
}
string result = escapeBuilder.ToString();
escapeBuilder.Length = 0;
return result;
}
private static JSONNode ParseElement(string token, bool quoted)
{
if (quoted)
{
return token;
}
if (token.Length <= 5)
{
string text = token.ToLower();
if (text == "false" || text == "true")
{
return text == "true";
}
if (text == "null")
{
return JSONNull.CreateOrGet();
}
}
if (double.TryParse(token, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
{
return result;
}
return token;
}
public static JSONNode Parse(string aJSON)
{
Stack<JSONNode> stack = new Stack<JSONNode>();
JSONNode jSONNode = null;
int i = 0;
StringBuilder stringBuilder = new StringBuilder();
string aKey = "";
bool flag = false;
bool flag2 = false;
bool flag3 = false;
for (; i < aJSON.Length; i++)
{
switch (aJSON[i])
{
case '{':
if (flag)
{
stringBuilder.Append(aJSON[i]);
break;
}
stack.Push(new JSONObject());
if (jSONNode != null)
{
jSONNode.Add(aKey, stack.Peek());
}
aKey = "";
stringBuilder.Length = 0;
jSONNode = stack.Peek();
flag3 = false;
break;
case '[':
if (flag)
{
stringBuilder.Append(aJSON[i]);
break;
}
stack.Push(new JSONArray());
if (jSONNode != null)
{
jSONNode.Add(aKey, stack.Peek());
}
aKey = "";
stringBuilder.Length = 0;
jSONNode = stack.Peek();
flag3 = false;
break;
case ']':
case '}':
if (flag)
{
stringBuilder.Append(aJSON[i]);
break;
}
if (stack.Count == 0)
{
throw new Exception("JSON Parse: Too many closing brackets");
}
stack.Pop();
if (stringBuilder.Length > 0 || flag2)
{
jSONNode.Add(aKey, ParseElement(stringBuilder.ToString(), flag2));
}
if (jSONNode != null)
{
jSONNode.Inline = !flag3;
}
flag2 = false;
aKey = "";
stringBuilder.Length = 0;
if (stack.Count > 0)
{
jSONNode = stack.Peek();
}
break;
case ':':
if (flag)
{
stringBuilder.Append(aJSON[i]);
break;
}
aKey = stringBuilder.ToString();
stringBuilder.Length = 0;
flag2 = false;
break;
case '"':
flag = !flag;
flag2 = flag2 || flag;
break;
case ',':
if (flag)
{
stringBuilder.Append(aJSON[i]);
break;
}
if (stringBuilder.Length > 0 || flag2)
{
jSONNode.Add(aKey, ParseElement(stringBuilder.ToString(), flag2));
}
flag2 = false;
aKey = "";
stringBuilder.Length = 0;
flag2 = false;
break;
case '\n':
case '\r':
flag3 = true;
break;
case '\t':
case ' ':
if (flag)
{
stringBuilder.Append(aJSON[i]);
}
break;
case '\\':
i++;
if (flag)
{
char c = aJSON[i];
switch (c)
{
case 't':
stringBuilder.Append('\t');
break;
case 'r':
stringBuilder.Append('\r');
break;
case 'n':
stringBuilder.Append('\n');
break;
case 'b':
stringBuilder.Append('\b');
break;
case 'f':
stringBuilder.Append('\f');
break;
case 'u':
{
string s = aJSON.Substring(i + 1, 4);
stringBuilder.Append((char)int.Parse(s, NumberStyles.AllowHexSpecifier));
i += 4;
break;
}
default:
stringBuilder.Append(c);
break;
}
}
break;
case '/':
if (allowLineComments && !flag && i + 1 < aJSON.Length && aJSON[i + 1] == '/')
{
while (++i < aJSON.Length && aJSON[i] != '\n' && aJSON[i] != '\r')
{
}
}
else
{
stringBuilder.Append(aJSON[i]);
}
break;
default:
stringBuilder.Append(aJSON[i]);
break;
case '\ufeff':
break;
}
}
if (flag)
{
throw new Exception("JSON Parse: Quotation marks seems to be messed up.");
}
if (jSONNode == null)
{
return ParseElement(stringBuilder.ToString(), flag2);
}
return jSONNode;
}
}
public class JSONArray : JSONNode
{
private List<JSONNode> m_List = new List<JSONNode>();
private bool inline = false;
public override bool Inline
{
get
{
return inline;
}
set
{
inline = value;
}
}
public override JSONNodeType Tag => JSONNodeType.Array;
public override bool IsArray => true;
public override JSONNode this[int aIndex]
{
get
{
if (aIndex < 0 || aIndex >= m_List.Count)
{
return new JSONLazyCreator(this);
}
return m_List[aIndex];
}
set
{
if (value == null)
{
value = JSONNull.CreateOrGet();
}
if (aIndex < 0 || aIndex >= m_List.Count)
{
m_List.Add(value);
}
else
{
m_List[aIndex] = value;
}
}
}
public override JSONNode this[string aKey]
{
get
{
return new JSONLazyCreator(this);
}
set
{
if (value == null)
{
value = JSONNull.CreateOrGet();
}
m_List.Add(value);
}
}
public override int Count => m_List.Count;
public override IEnumerable<JSONNode> Children
{
get
{
foreach (JSONNode item in m_List)
{
yield return item;
}
}
}
public override Enumerator GetEnumerator()
{
return new Enumerator(m_List.GetEnumerator());
}
public override void Add(string aKey, JSONNode aItem)
{
if (aItem == null)
{
aItem = JSONNull.CreateOrGet();
}
m_List.Add(aItem);
}
public override JSONNode Remove(int aIndex)
{
if (aIndex < 0 || aIndex >= m_List.Count)
{
return null;
}
JSONNode result = m_List[aIndex];
m_List.RemoveAt(aIndex);
return result;
}
public override JSONNode Remove(JSONNode aNode)
{
m_List.Remove(aNode);
return aNode;
}
public override void Clear()
{
m_List.Clear();
}
public override JSONNode Clone()
{
JSONArray jSONArray = new JSONArray();
jSONArray.m_List.Capacity = m_List.Capacity;
foreach (JSONNode item in m_List)
{
if (item != null)
{
jSONArray.Add(item.Clone());
}
else
{
jSONArray.Add(null);
}
}
return jSONArray;
}
internal override void WriteToStringBuilder(StringBuilder aSB, int aIndent, int aIndentInc, JSONTextMode aMode)
{
aSB.Append('[');
int count = m_List.Count;
if (inline)
{
aMode = JSONTextMode.Compact;
}
for (int i = 0; i < count; i++)
{
if (i > 0)
{
aSB.Append(',');
}
if (aMode == JSONTextMode.Indent)
{
aSB.AppendLine();
}
if (aMode == JSONTextMode.Indent)
{
aSB.Append(' ', aIndent + aIndentInc);
}
m_List[i].WriteToStringBuilder(aSB, aIndent + aIndentInc, aIndentInc, aMode);
}
if (aMode == JSONTextMode.Indent)
{
aSB.AppendLine().Append(' ', aIndent);
}
aSB.Append(']');
}
}
public class JSONObject : JSONNode
{
private Dictionary<string, JSONNode> m_Dict = new Dictionary<string, JSONNode>();
private bool inline = false;
public override bool Inline
{
get
{
return inline;
}
set
{
inline = value;
}
}
public override JSONNodeType Tag => JSONNodeType.Object;
public override bool IsObject => true;
public override JSONNode this[string aKey]
{
get
{
if (m_Dict.ContainsKey(aKey))
{
return m_Dict[aKey];
}
return new JSONLazyCreator(this, aKey);
}
set
{
if (value == null)
{
value = JSONNull.CreateOrGet();
}
if (m_Dict.ContainsKey(aKey))
{
m_Dict[aKey] = value;
}
else
{
m_Dict.Add(aKey, value);
}
}
}
public override JSONNode this[int aIndex]
{
get
{
if (aIndex < 0 || aIndex >= m_Dict.Count)
{
return null;
}
return m_Dict.ElementAt(aIndex).Value;
}
set
{
if (value == null)
{
value = JSONNull.CreateOrGet();
}
if (aIndex >= 0 && aIndex < m_Dict.Count)
{
string key = m_Dict.ElementAt(aIndex).Key;
m_Dict[key] = value;
}
}
}
public override int Count => m_Dict.Count;
public override IEnumerable<JSONNode> Children
{
get
{
foreach (KeyValuePair<string, JSONNode> item in m_Dict)
{
yield return item.Value;
}
}
}
public override Enumerator GetEnumerator()
{
return new Enumerator(m_Dict.GetEnumerator());
}
public override void Add(string aKey, JSONNode aItem)
{
if (aItem == null)
{
aItem = JSONNull.CreateOrGet();
}
if (aKey != null)
{
if (m_Dict.ContainsKey(aKey))
{
m_Dict[aKey] = aItem;
}
else
{
m_Dict.Add(aKey, aItem);
}
}
else
{
m_Dict.Add(Guid.NewGuid().ToString(), aItem);
}
}
public override JSONNode Remove(string aKey)
{
if (!m_Dict.ContainsKey(aKey))
{
return null;
}
JSONNode result = m_Dict[aKey];
m_Dict.Remove(aKey);
return result;
}
public override JSONNode Remove(int aIndex)
{
if (aIndex < 0 || aIndex >= m_Dict.Count)
{
return null;
}
KeyValuePair<string, JSONNode> keyValuePair = m_Dict.ElementAt(aIndex);
m_Dict.Remove(keyValuePair.Key);
return keyValuePair.Value;
}
public override JSONNode Remove(JSONNode aNode)
{
try
{
KeyValuePair<string, JSONNode> keyValuePair = m_Dict.Where((KeyValuePair<string, JSONNode> k) => k.Value == aNode).First();
m_Dict.Remove(keyValuePair.Key);
return aNode;
}
catch
{
return null;
}
}
public override void Clear()
{
m_Dict.Clear();
}
public override JSONNode Clone()
{
JSONObject jSONObject = new JSONObject();
foreach (KeyValuePair<string, JSONNode> item in m_Dict)
{
jSONObject.Add(item.Key, item.Value.Clone());
}
return jSONObject;
}
public override bool HasKey(string aKey)
{
return m_Dict.ContainsKey(aKey);
}
public override JSONNode GetValueOrDefault(string aKey, JSONNode aDefault)
{
if (m_Dict.TryGetValue(aKey, out var value))
{
return value;
}
return aDefault;
}
internal override void WriteToStringBuilder(StringBuilder aSB, int aIndent, int aIndentInc, JSONTextMode aMode)
{
aSB.Append('{');
bool flag = true;
if (inline)
{
aMode = JSONTextMode.Compact;
}
foreach (KeyValuePair<string, JSONNode> item in m_Dict)
{
if (!flag)
{
aSB.Append(',');
}
flag = false;
if (aMode == JSONTextMode.Indent)
{
aSB.AppendLine();
}
if (aMode == JSONTextMode.Indent)
{
aSB.Append(' ', aIndent + aIndentInc);
}
aSB.Append('"').Append(JSONNode.Escape(item.Key)).Append('"');
if (aMode == JSONTextMode.Compact)
{
aSB.Append(':');
}
else
{
aSB.Append(" : ");
}
item.Value.WriteToStringBuilder(aSB, aIndent + aIndentInc, aIndentInc, aMode);
}
if (aMode == JSONTextMode.Indent)
{
aSB.AppendLine().Append(' ', aIndent);
}
aSB.Append('}');
}
}
public class JSONString : JSONNode
{
private string m_Data;
public override JSONNodeType Tag => JSONNodeType.String;
public override bool IsString => true;
public override string Value
{
get
{
return m_Data;
}
set
{
m_Data = value;
}
}
public override Enumerator GetEnumerator()
{
return default(Enumerator);
}
public JSONString(string aData)
{
m_Data = aData;
}
public override JSONNode Clone()
{
return new JSONString(m_Data);
}
internal override void WriteToStringBuilder(StringBuilder aSB, int aIndent, int aIndentInc, JSONTextMode aMode)
{
aSB.Append('"').Append(JSONNode.Escape(m_Data)).Append('"');
}
public override bool Equals(object obj)
{
if (base.Equals(obj))
{
return true;
}
if (obj is string text)
{
return m_Data == text;
}
JSONString jSONString = obj as JSONString;
if (jSONString != null)
{
return m_Data == jSONString.m_Data;
}
return false;
}
public override int GetHashCode()
{
return m_Data.GetHashCode();
}
public override void Clear()
{
m_Data = "";
}
}
public class JSONNumber : JSONNode
{
private double m_Data;
public override JSONNodeType Tag => JSONNodeType.Number;
public override bool IsNumber => true;
public override string Value
{
get
{
return m_Data.ToString(CultureInfo.InvariantCulture);
}
set
{
if (double.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
{
m_Data = result;
}
}
}
public override double AsDouble
{
get
{
return m_Data;
}
set
{
m_Data = value;
}
}
public override long AsLong
{
get
{
return (long)m_Data;
}
set
{
m_Data = value;
}
}
public override ulong AsULong
{
get
{
return (ulong)m_Data;
}
set
{
m_Data = value;
}
}
public override Enumerator GetEnumerator()
{
return default(Enumerator);
}
public JSONNumber(double aData)
{
m_Data = aData;
}
public JSONNumber(string aData)
{
Value = aData;
}
public override JSONNode Clone()
{
return new JSONNumber(m_Data);
}
internal override void WriteToStringBuilder(StringBuilder aSB, int aIndent, int aIndentInc, JSONTextMode aMode)
{
aSB.Append(Value.ToString(CultureInfo.InvariantCulture));
}
private static bool IsNumeric(object value)
{
return value is int || value is uint || value is float || value is double || value is decimal || value is long || value is ulong || value is short || value is ushort || value is sbyte || value is byte;
}
public override bool Equals(object obj)
{
if (obj == null)
{
return false;
}
if (base.Equals(obj))
{
return true;
}
JSONNumber jSONNumber = obj as JSONNumber;
if (jSONNumber != null)
{
return m_Data == jSONNumber.m_Data;
}
if (IsNumeric(obj))
{
return Convert.ToDouble(obj) == m_Data;
}
return false;
}
public override int GetHashCode()
{
return m_Data.GetHashCode();
}
public override void Clear()
{
m_Data = 0.0;
}
}
public class JSONBool : JSONNode
{
private bool m_Data;
public override JSONNodeType Tag => JSONNodeType.Boolean;
public override bool IsBoolean => true;
public override string Value
{
get
{
return m_Data.ToString();
}
set
{
if (bool.TryParse(value, out var result))
{
m_Data = result;
}
}
}
public override bool AsBool
{
get
{
return m_Data;
}
set
{
m_Data = value;
}
}
public override Enumerator GetEnumerator()
{
return default(Enumerator);
}
public JSONBool(bool aData)
{
m_Data = aData;
}
public JSONBool(string aData)
{
Value = aData;
}
public override JSONNode Clone()
{
return new JSONBool(m_Data);
}
internal override void WriteToStringBuilder(StringBuilder aSB, int aIndent, int aIndentInc, JSONTextMode aMode)
{
aSB.Append(m_Data ? "true" : "false");
}
public override bool Equals(object obj)
{
if (obj == null)
{
return false;
}
if (obj is bool)
{
return m_Data == (bool)obj;
}
return false;
}
public override int GetHashCode()
{
return m_Data.GetHashCode();
}
public override void Clear()
{
m_Data = false;
}
}
public class JSONNull : JSONNode
{
private static JSONNull m_StaticInstance = new JSONNull();
public static bool reuseSameInstance = true;
public override JSONNodeType Tag => JSONNodeType.NullValue;
public override bool IsNull => true;
public override string Value
{
get
{
return "null";
}
set
{
}
}
public override bool AsBool
{
get
{
return false;
}
set
{
}
}
public static JSONNull CreateOrGet()
{
if (reuseSameInstance)
{
return m_StaticInstance;
}
return new JSONNull();
}
private JSONNull()
{
}
public override Enumerator GetEnumerator()
{
return default(Enumerator);
}
public override JSONNode Clone()
{
return CreateOrGet();
}
public override bool Equals(object obj)
{
if ((object)this == obj)
{
return true;
}
return obj is JSONNull;
}
public override int GetHashCode()
{
return 0;
}
internal override void WriteToStringBuilder(StringBuilder aSB, int aIndent, int aIndentInc, JSONTextMode aMode)
{
aSB.Append("null");
}
}
internal class JSONLazyCreator : JSONNode
{
private JSONNode m_Node = null;
private string m_Key = null;
public override JSONNodeType Tag => JSONNodeType.None;
public override JSONNode this[int aIndex]
{
get
{
return new JSONLazyCreator(this);
}
set
{
Set(new JSONArray()).Add(value);
}
}
public override JSONNode this[string aKey]
{
get
{
return new JSONLazyCreator(this, aKey);
}
set
{
Set(new JSONObject()).Add(aKey, value);
}
}
public override int AsInt
{
get
{
Set(new JSONNumber(0.0));
return 0;
}
set
{
Set(new JSONNumber(value));
}
}
public override float AsFloat
{
get
{
Set(new JSONNumber(0.0));
return 0f;
}
set
{
Set(new JSONNumber(value));
}
}
public override double AsDouble
{
get
{
Set(new JSONNumber(0.0));
return 0.0;
}
set
{
Set(new JSONNumber(value));
}
}
public override long AsLong
{
get
{
if (JSONNode.longAsString)
{
Set(new JSONString("0"));
}
else
{
Set(new JSONNumber(0.0));
}
return 0L;
}
set
{
if (JSONNode.longAsString)
{
Set(new JSONString(value.ToString(CultureInfo.InvariantCulture)));
}
else
{
Set(new JSONNumber(value));
}
}
}
public override ulong AsULong
{
get
{
if (JSONNode.longAsString)
{
Set(new JSONString("0"));
}
else
{
Set(new JSONNumber(0.0));
}
return 0uL;
}
set
{
if (JSONNode.longAsString)
{
Set(new JSONString(value.ToString(CultureInfo.InvariantCulture)));
}
else
{
Set(new JSONNumber(value));
}
}
}
public override bool AsBool
{
get
{
Set(new JSONBool(aData: false));
return false;
}
set
{
Set(new JSONBool(value));
}
}
public override JSONArray AsArray => Set(new JSONArray());
public override JSONObject AsObject => Set(new JSONObject());
public override Enumerator GetEnumerator()
{
return default(Enumerator);
}
public JSONLazyCreator(JSONNode aNode)
{
m_Node = aNode;
m_Key = null;
}
public JSONLazyCreator(JSONNode aNode, string aKey)
{
m_Node = aNode;
m_Key = aKey;
}
private T Set<T>(T aVal) where T : JSONNode
{
if (m_Key == null)
{
m_Node.Add(aVal);
}
else
{
m_Node.Add(m_Key, aVal);
}
m_Node = null;
return aVal;
}
public override void Add(JSONNode aItem)
{
Set(new JSONArray()).Add(aItem);
}
public override void Add(string aKey, JSONNode aItem)
{
Set(new JSONObject()).Add(aKey, aItem);
}
public static bool operator ==(JSONLazyCreator a, object b)
{
if (b == null)
{
return true;
}
return (object)a == b;
}
public static bool operator !=(JSONLazyCreator a, object b)
{
return !(a == b);
}
public override bool Equals(object obj)
{
if (obj == null)
{
return true;
}
return (object)this == obj;
}
public override int GetHashCode()
{
return 0;
}
internal override void WriteToStringBuilder(StringBuilder aSB, int aIndent, int aIndentInc, JSONTextMode aMode)
{
aSB.Append("null");
}
}
public static class JSON
{
public static JSONNode Parse(string aJSON)
{
return JSONNode.Parse(aJSON);
}
}
}
namespace GoreBoxCheat
{
public static class ACKill
{
private static GameObject cachedApplicationMaster;
public static string gameMode;
public static void StartMonitoring(MonoBehaviour host)
{
MonoBehaviourExtensions.StartCoroutine(host, MonitorAntiCheatToolkit());
}
private static IEnumerator MonitorAntiCheatToolkit()
{
while (true)
{
DestroyAntiCheatToolkit();
yield return (object)new WaitForSeconds(1f);
}
}
private static void DestroyAntiCheatToolkit()
{
if ((Object)(object)cachedApplicationMaster == (Object)null || !Object.op_Implicit((Object)(object)cachedApplicationMaster))
{
GameObject[] array = Il2CppArrayBase<GameObject>.op_Implicit(Resources.FindObjectsOfTypeAll<GameObject>());
GameObject[] array2 = array;
foreach (GameObject val in array2)
{
if (((Object)val).name == "APPLICATION MASTER")
{
cachedApplicationMaster = val;
break;
}
}
}
if ((Object)(object)cachedApplicationMaster != (Object)null)
{
Transform val2 = cachedApplicationMaster.transform.Find("Anti-Cheat Toolkit");
if ((Object)(object)val2 != (Object)null)
{
Object.Destroy((Object)(object)((Component)val2).gameObject);
}
gameMode = cachedApplicationMaster.GetComponent<ConnectionMaster>().HEGBHGFHBDHGCAB.ACCGGEAEDHFGCHF.Name;
}
}
}
public static class Bypass
{
[HarmonyPatch(typeof(PlayFabUnityHttp), "OnResponse")]
public class PlayFabBypass
{
private static bool Prefix(ref string response, CallRequestContainer reqContainer)
{
if (reqContainer.FullUrl.Contains("LoginWithAndroidDeviceID"))
{
if (response.Contains("AccountBanned"))
{
Debug.Log(Object.op_Implicit("Account banned, using proxy... (wait)"));
banned = true;
spoofID = true;
}
string aJSON = LoginProxy.PlayfabPost(reqContainer, banned);
JSONNode jSONNode = JSON.Parse(aJSON);
realID = jSONNode["data"]["PlayFabId"].Value;
if (spoofID)
{
jSONNode["data"]["PlayFabId"] = randomID;
Debug.Log(Object.op_Implicit("REAL ID: " + realID));
Debug.Log(Object.op_Implicit("FAKE ID: " + randomID));
}
response = jSONNode.ToString();
}
if (spoofID && reqContainer.FullUrl.Contains("GetAccountInfo"))
{
string aJSON2 = LoginProxy.PlayfabPost(reqContainer, banned);
JSONNode jSONNode2 = JSON.Parse(aJSON2);
jSONNode2["data"]["AccountInfo"]["PlayFabId"] = randomID;
response = jSONNode2.ToString();
}
if (banned)
{
if (reqContainer.FullUrl.Contains("ReportDeviceInfo"))
{
response = "{\"code\":200,\"status\":\"OK\",\"data\":{}}";
}
else if (reqContainer.FullUrl.Contains("WriteEvents"))
{
response = "{\"code\":200,\"status\":\"OK\",\"data\":{\"AssignedEventIds\":[\"2bc4a1d2a11549469c704e1791101edf\"]}}";
}
else if (reqContainer.FullUrl.Contains("GetPhotonAuthenticationToken"))
{
response = LoginProxy.PlayfabPost(reqContainer);
}
else if (reqContainer.FullUrl.Contains("GetFriendsList"))
{
response = "{\"code\":200,\"status\":\"OK\",\"data\":{\"Friends\":[]}}";
}
}
if (reqContainer.FullUrl.Contains("GetUserData") && devBadge)
{
response = "{\"code\":200,\"status\":\"OK\",\"data\":{\"Data\":{" + badgePayload + "},\"DataVersion\":0}}";
}
return true;
}
}
[HarmonyPatch(typeof(PlayFabClientAPI), "LoginWithSteam")]
public static class PlayFabClientAPIPatch
{
private static bool Prefix(LoginWithSteamRequest request, Action<LoginResult> resultCallback, Action<PlayFabError> errorCallback, Object customData = null, Dictionary<string, string> extraHeaders = null)
{
//IL_0014: 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)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: 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_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: 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_0071: 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_008c: Expected O, but got Unknown
if (!spoofID)
{
return true;
}
LoginWithAndroidDeviceIDRequest val = new LoginWithAndroidDeviceIDRequest
{
AndroidDevice = GenerateAndroidDeviceName(),
AndroidDeviceId = randomDevice,
CreateAccount = new Nullable<bool>(true),
CustomTags = request.CustomTags,
EncryptedRequest = request.EncryptedRequest,
InfoRequestParameters = request.InfoRequestParameters,
OS = "Android",
PlayerSecret = request.PlayerSecret,
TitleId = request.TitleId
};
Debug.Log(Object.op_Implicit("Using Spoofed ID to Authenticate with PlayFab..."));
PlayFabClientAPI.LoginWithAndroidDeviceID(val, Action<LoginResult>.op_Implicit(resultCallback), Action<PlayFabError>.op_Implicit(errorCallback), customData, extraHeaders);
return false;
}
}
[HarmonyPatch(typeof(PlayFabClientInstanceAPI), "LoginWithSteam")]
public static class PlayFabClientInstanceAPIPatch
{
private static bool Prefix(PlayFabClientInstanceAPI __instance, LoginWithSteamRequest request, Action<LoginResult> resultCallback, Action<PlayFabError> errorCallback, Object customData = null, Dictionary<string, string> extraHeaders = null)
{
//IL_0014: 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)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: 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_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: 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_0071: 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_008c: Expected O, but got Unknown
if (!spoofID)
{
return true;
}
LoginWithAndroidDeviceIDRequest val = new LoginWithAndroidDeviceIDRequest
{
AndroidDevice = GenerateAndroidDeviceName(),
AndroidDeviceId = randomDevice,
CreateAccount = new Nullable<bool>(true),
CustomTags = request.CustomTags,
EncryptedRequest = request.EncryptedRequest,
InfoRequestParameters = request.InfoRequestParameters,
OS = "Android",
PlayerSecret = request.PlayerSecret,
TitleId = request.TitleId
};
Debug.Log(Object.op_Implicit("Using Spoofed ID to Authenticate with PlayFab..."));
__instance.LoginWithAndroidDeviceID(val, Action<LoginResult>.op_Implicit(resultCallback), Action<PlayFabError>.op_Implicit(errorCallback), customData, extraHeaders);
return false;
}
}
[HarmonyPatch(typeof(LoadBalancingPeer), "OpAuthenticate")]
public static class pAuthPeer0
{
private static bool Prefix(string appId, string appVersion, ref AuthenticationValues authValues, string regionCode, bool getLobbyStatistics)
{
if (spoofID || banned)
{
authValues.AuthGetParameters = authValues.AuthGetParameters.Replace(randomID, realID);
}
return true;
}
}
[HarmonyPatch(typeof(GameMaster), "GiveWeapon")]
public static class GiveWeaponBypass
{
private static bool Prefix(string name)
{
WeaponSwitcher componentInChildren = localPlayer.GetComponentInChildren<WeaponSwitcher>();
float value = Random.value;
ConnectionMaster.BAHHEHCHFGGFGDD.ABGHACABFFFBBCD = value;
componentInChildren.FDAAEEGBACAABFH(name, -1, (float)((double)value * 0.95240003), 0, 0);
return false;
}
}
[HarmonyPatch(typeof(GameMode), "get_hostPerms")]
public static class HostPermBypass_Get
{
private static bool Prefix(ref ObscuredBool __result)
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
if (hostPerms)
{
__result = new ObscuredBool(true);
return false;
}
return true;
}
}
[HarmonyPatch(typeof(PhotonNetwork), "get_IsMasterClient")]
public static class PhotonisMasterClientBypass
{
private static bool Prefix(ref ObscuredBool __result)
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
if (hostPerms)
{
__result = new ObscuredBool(true);
return false;
}
return true;
}
}
[HarmonyPatch(typeof(Player), "get_IsMasterClient")]
public static class PlayerisMasterClientBypass
{
private static bool Prefix(Player __instance, ref ObscuredBool __result)
{
//IL_0018: 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)
if (__instance.IsLocal)
{
if (hostPerms)
{
__result = new ObscuredBool(true);
return false;
}
return true;
}
return true;
}
}
[HarmonyPatch(typeof(ConnectionMaster), "DBGFGCECFECBACC", new Type[] { })]
public static class HostCheckBypass
{
private static bool Prefix(ref bool __result)
{
if (hostPerms)
{
__result = true;
return false;
}
return true;
}
}
[HarmonyPatch(typeof(ConnectionMaster), "DBGFGCECFECBACC", new Type[] { typeof(Player) })]
public static class HostCheckBypassPlayer
{
private static bool Prefix(ref bool __result)
{
if (hostPerms)
{
__result = true;
return false;
}
return true;
}
}
[HarmonyPatch(typeof(PhotonNetwork), "Disconnect")]
public static class DisconnectBypass
{
private static bool Prefix()
{
if (antiKick)
{
return false;
}
return true;
}
}
[HarmonyPatch(typeof(PhotonNetwork), "LeaveRoom")]
public static class LeaveBypass
{
private static bool Prefix()
{
if (antiKick)
{
return false;
}
return true;
}
}
[HarmonyPatch(typeof(PhotonNetwork), "DestroyPlayerObjects", new Type[]
{
typeof(int),
typeof(bool),
typeof(float)
})]
public static class DestroyPlayerObjectsBypass0
{
private static bool Prefix(int playerId, bool localOnly, float key)
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
if (antiKick && playerId == PhotonNetwork.LocalPlayer.ActorNumber.fakeValue)
{
return false;
}
return true;
}
}
[HarmonyPatch(typeof(PhotonNetwork), "DestroyPlayerObjects", new Type[]
{
typeof(int),
typeof(float)
})]
public static class DestroyPlayerObjectsBypass1
{
private static bool Prefix(int targetPlayerId, float key)
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
if (antiKick && targetPlayerId == PhotonNetwork.LocalPlayer.ActorNumber.fakeValue)
{
return false;
}
return true;
}
}
[HarmonyPatch(typeof(PhotonNetwork), "DestroyPlayerObjects", new Type[]
{
typeof(Player),
typeof(float)
})]
public static class DestroyPlayerObjectsBypass2
{
private static bool Prefix(Player targetPlayer, float key)
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
if (antiKick && targetPlayer.ActorNumber.fakeValue == PhotonNetwork.LocalPlayer.ActorNumber.fakeValue)
{
return false;
}
return true;
}
}
[HarmonyPatch(typeof(PhotonNetwork), "OnEvent")]
public static class OnEventBypass
{
private static bool Prefix(EventData photonEvent)
{
return !ShouldBypassEvent(photonEvent);
}
}
[HarmonyPatch(typeof(LoadBalancingClient), "OnEvent")]
public static class OnEventBypassLBC
{
private static bool Prefix(EventData photonEvent)
{
return !ShouldBypassEvent(photonEvent);
}
}
[HarmonyPatch(typeof(PlayerMaster), "CBBAGAHCBBCDEFF")]
public static class AntiTP
{
private static bool Prefix(Vector3 BFDCFHADAFHHFDH, PhotonMessageInfo GDFFHFCCGCBEHEH)
{
if (antiMod)
{
return false;
}
return true;
}
}
[HarmonyPatch(typeof(GameRules), "EDCFBBHHDDFFCAC")]
public static class AntiGameRuleChange
{
private static bool Prefix(bool BGBFDHEFFEEHHDB, bool AHAHEFEHEGDEAGC, bool EDECHHHGACHCHCH, bool HHEAECGDCHDDDED, bool DCDCBEGEDHEADED, bool EHDFGAFHAEHGFAC, bool HCGHHBECEHDBHHF, bool AEEHFDBBFFGEFFC, bool BDFEEGFHHCBHBHG, bool BGFBGHFADDAEHFB, bool ACAFBEDHHADBBFH, bool ACCGDAHDHAFCDBC, bool FFGCGHGDGGBHHFA, bool GHACBBCHDAFHEEA, bool GGACGCFDCAECHBB, bool ADEDFCDGDDCEAAG, bool BFBHGBAGDAHEEHH, bool HAFGFABGAHBFDBB, bool GDGEDBGGCHFAACH, bool FGEBHDFFCCDBGAC, bool HFHCBDGEBCFGHAH, bool CEEGFDHFBBHFGDH, bool DEGFHDBBAABFBAC, bool DFGDDBBACGBFEHH, bool FDBAEAHDAFDEHDC, bool EAFABBEHCBCGGAE, bool HHDAGFFBEDFFAHB, bool ECFDCCHGDHDDFDD, bool EAEHCFEEGAGCCEE, bool EADGBEEGBBADACE, bool FFAGECAGFHCBBDD, bool BCGDFEADHDFEFGE, bool FCEAGBGAEHHFAEE, bool DEEFHCACFHFDHDA, float AAEGBDHDAACHDFF, bool CGGCBFHEGGGFECD, bool EBEEDCABCBEFFDA, bool BBEEDBBHCFHHCAG, bool AECFCACEDGACAAH)
{
if (antiMod)
{
return false;
}
return true;
}
}
[HarmonyPatch(typeof(Spawnlimit), "Awake")]
public static class SpawnLimitBypass
{
private static bool Prefix(Spawnlimit __instance)
{
((Behaviour)__instance).enabled = false;
return false;
}
}
[HarmonyPatch(typeof(SpamDetect), "Awake")]
public static class SpawnSpamBypass
{
private static bool Prefix(SpamDetect __instance)
{
((Behaviour)__instance).enabled = false;
return false;
}
}
[HarmonyPatch(typeof(Explosive), "Start")]
public static class BigExplosive
{
private static void Postfix(Explosive __instance)
{
if (bigExplosive && ((MonoBehaviourPun)__instance).photonView.Owner == PhotonNetwork.LocalPlayer)
{
__instance.FDAFEBHHFEEFCGA = 1000000f;
__instance.HADFHEHECFGEBCC = 1000000f;
}
}
}
public static GameObject localPlayer;
public static bool hostPerms = false;
public static bool antiKick = false;
public static bool spoofID = false;
public static bool antiMod = false;
public static bool devBadge = false;
public static bool bigExplosive = false;
private static byte[] kickCodes = new byte[3] { 203, 207, 204 };
public static string randomID;
public static string randomDevice;
public static string realID;
public static bool banned = false;
public static string badgeID = "8";
private static string userDataRecord = "{\"LastUpdated\":\"2024-11-28T15:44:28.339Z\",\"Permission\":1,\"Value\":\"" + badgeID + "namehere\"}";
private static string badgePayload = "\"BDGAFFAEDHCDDDF\":" + userDataRecord + ",\"Badge\":" + userDataRecord;
public static string GenerateRandomId(bool nullID = false)
{
if (nullID)
{
return "0000000000000000";
}
StringBuilder stringBuilder = new StringBuilder(16);
Random random = new Random();
for (int i = 0; i < 16; i++)
{
stringBuilder.Append("ABCDEF0123456789"[random.Next("ABCDEF0123456789".Length)]);
}
return stringBuilder.ToString();
}
private static string GenerateAndroidDeviceName()
{
return "Generic Android Device";
}
public static string GenerateAndroidDeviceId()
{
Random random = new Random();
string text = "Android_";
for (int i = 0; i < 16; i++)
{
text += "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"[random.Next("ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".Length)];
}
return text;
}
public static void ForceHost()
{
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: 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_002b: Expected O, but got Unknown
if (PhotonNetwork.LocalPlayer == null)
{
return;
}
ObscuredInt actorNumber = PhotonNetwork.LocalPlayer.ActorNumber;
int num = ((ObscuredInt)(ref actorNumber)).EFGHDBGDHBHHBHB();
Hashtable val = new Hashtable();
val.Add((byte)248, Object.op_Implicit(num));
((Dictionary<Object, Object>)(object)val).Add(Object.op_Implicit("h"), Object.op_Implicit(realID));
Hashtable val2 = null;
if (PhotonNetwork.CurrentRoom != null)
{
bool flag = PhotonNetwork.CurrentRoom.LoadBalancingClient.OpSetPropertiesOfRoom(val, val2, (WebFlags)null);
bool flag2 = PhotonNetwork.CurrentRoom.SetCustomProperties(val, (Hashtable)null, (WebFlags)null);
if (!flag || !flag2)
{
Debug.Log(Object.op_Implicit($"Failed to force Master Client role.\r\nS1:{flag} | S2:{flag2}"));
}
}
}
private static bool ShouldBypassEvent(EventData photonEvent)
{
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
if (antiKick && kickCodes.Contains(photonEvent.Code))
{
if (photonEvent.Code == 204)
{
Hashtable val = ((Il2CppObjectBase)photonEvent.CustomData).Cast<Hashtable>();
int num = ((Il2CppObjectBase)val[PhotonNetwork.keyByteZero]).Unbox<int>();
if (num != PhotonNetwork.LocalPlayer.ActorNumber.fakeValue)
{
return false;
}
}
return true;
}
return false;
}
}
[BepInPlugin("com.indica.goreboxcheat", "Gorebox Cheat", "1.3.1")]
public class GoreBoxCheat : BasePlugin
{
private GameObject _utilityGameObject;
public override void Load()
{
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Expected O, but got Unknown
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Expected O, but got Unknown
ClassInjector.RegisterTypeInIl2Cpp<GoreBoxCheatBehaviour>();
_utilityGameObject = GameObject.Find("GoreBoxCheatUtility");
if ((Object)(object)_utilityGameObject == (Object)null)
{
_utilityGameObject = new GameObject("GoreBoxCheatUtility");
Object.DontDestroyOnLoad((Object)(object)_utilityGameObject);
((Object)_utilityGameObject).hideFlags = (HideFlags)61;
}
_utilityGameObject.AddComponent<GoreBoxCheatBehaviour>();
Harmony val = new Harmony("com.indica.goreboxcheatharmony");
val.PatchAll();
}
}
public class GoreBoxCheatBehaviour : MonoBehaviourPunCallbacks
{
private readonly Regex playerNameRegex = new Regex("^Player\\d+$");
private GameObject localPlayer;
private Camera gameCamera;
private GameMaster gameMaster;
private readonly List<(Vector3 ScreenPosition, string Text, bool IsVisible)> labelsToRender = new List<(Vector3, string, bool)>();
private List<PlayerMaster> playerList = new List<PlayerMaster>();
private GUIStyle labelStyleVisible;
private GUIStyle labelStyleInvisible;
private UI ui;
private float fovRadius = 150f;
public GoreBoxCheatBehaviour(IntPtr ptr)
: base(ptr)
{
}
private void Start()
{
Bypass.randomID = Bypass.GenerateRandomId();
Bypass.randomDevice = Bypass.GenerateAndroidDeviceId();
ui = new UI();
ui.Start();
ACKill.StartMonitoring((MonoBehaviour)(object)this);
MonoBehaviourExtensions.StartCoroutine((MonoBehaviour)(object)this, EnableSpawning());
MonoBehaviourExtensions.StartCoroutine((MonoBehaviour)(object)this, GlobalUpdater());
SceneManager.sceneLoaded += UnityAction<Scene, LoadSceneMode>.op_Implicit((Action<Scene, LoadSceneMode>)OnSceneLoaded);
}
private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
{
localPlayer = null;
gameCamera = null;
labelsToRender.Clear();
}
private void Update()
{
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
if (Input.GetKeyDown((KeyCode)290))
{
ui.showUI = !ui.showUI;
}
ui.Update();
IdentifyLocalPlayer();
LocateCamera();
ShowPasswords();
ModifyLocalHashTable();
if (!((Object)(object)localPlayer == (Object)null) && !((Object)(object)gameCamera == (Object)null))
{
localPlayer.transform.rotation = Quaternion.Euler(0f, 0f, 0f);
HandleAimbot();
UpdateESPLabels();
HandleCheats();
}
}
private void OnGUI()
{
//IL_0034: 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_0059: Unknown result type (might be due to invalid IL or missing references)
if (ui.isESPEnabled)
{
InitializeStyles();
foreach (var item in labelsToRender)
{
GUI.Label(new Rect(item.ScreenPosition.x - 50f, item.ScreenPosition.y, 100f, 20f), item.Text, item.IsVisible ? labelStyleVisible : labelStyleInvisible);
}
}
if (ui.aimbotMode != 0)
{
DrawFovCircle();
}
ui.OnGUI();
}
private void ModifyLocalHashTable()
{
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Expected O, but got Unknown
Player val = PhotonNetwork.LocalPlayer;
if (val == null || ui.badgeSpoof == BadgeSpoof.Off || !((Dictionary<Object, Object>)(object)val.CustomProperties).ContainsKey(Object.op_Implicit("I")))
{
return;
}
Hashtable val2 = new Hashtable();
switch (ui.badgeSpoof)
{
case BadgeSpoof.Off:
break;
case BadgeSpoof.Empty:
if (((Il2CppObjectBase)val.CustomProperties[Object.op_Implicit("I")]).Unbox<int>() != 5)
{
((Dictionary<Object, Object>)(object)val2).Add(Object.op_Implicit("I"), Object.op_Implicit(5));
val.SetCustomProperties(val2, (Hashtable)null, (WebFlags)null);
}
break;
case BadgeSpoof.Developer:
if (((Il2CppObjectBase)val.CustomProperties[Object.op_Implicit("I")]).Unbox<int>() != 20)
{
((Dictionary<Object, Object>)(object)val2).Add(Object.op_Implicit("I"), Object.op_Implicit(20));
val.SetCustomProperties(val2, (Hashtable)null, (WebFlags)null);
}
break;
}
}
private void ShowPasswords()
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
Scene activeScene = SceneManager.GetActiveScene();
if (!(((Scene)(ref activeScene)).name == "sys_Menu"))
{
return;
}
GameObject val = GameObject.Find("Menu/WidgetMaster/1Play/ServerList/ServerHolder/Scroll View/Viewport/Content/");
if (!((Object)(object)val != (Object)null))
{
return;
}
ServerListing[] array = Il2CppArrayBase<ServerListing>.op_Implicit(val.GetComponentsInChildren<ServerListing>());
ServerListing[] array2 = array;
foreach (ServerListing val2 in array2)
{
RoomInfo val3 = ReflectionHelper.FindVariableByType<RoomInfo>(val2);
string text = val3.customProperties[Object.op_Implicit("p")].ToString();
if (!val2.BAECEAFFABAHDCC.text.Contains("Password"))
{
TMP_Text bAECEAFFABAHDCC = val2.BAECEAFFABAHDCC;
bAECEAFFABAHDCC.text = bAECEAFFABAHDCC.text + " | Password : " + text;
}
}
}
private IEnumerator GlobalUpdater()
{
while (true)
{
if ((Object)(object)localPlayer != (Object)null || (Object)(object)gameCamera != (Object)null)
{
GoreBoxCheatBehaviour goreBoxCheatBehaviour = this;
Scene activeScene = SceneManager.GetActiveScene();
goreBoxCheatBehaviour.playerList = ((IEnumerable<GameObject>)((Scene)(ref activeScene)).GetRootGameObjects()).SelectMany((GameObject root) => (IEnumerable<PlayerMaster>)root.GetComponentsInChildren<PlayerMaster>(true)).ToList();
GameObject gameMasterObject = GameObject.Find("GameMaster");
gameMaster = gameMasterObject.GetComponent<GameMaster>();
((Behaviour)gameMasterObject.GetComponent<ChatMaster>()).enabled = true;
}
yield return (object)new WaitForSeconds(1f);
}
}
private IEnumerator EnableSpawning()
{
while (true)
{
if (Bypass.hostPerms && (Object)(object)gameMaster != (Object)null)
{
Transform gunMenu = ((Component)gameMaster).gameObject.transform.Find("CF2-Rig/CF2-Canvas/CF2-Panel/PanelManager/MenuPanel/");
if ((Object)(object)gunMenu != (Object)null)
{
PanelManager panelManager = ((Component)((Component)gameMaster).gameObject.transform.Find("CF2-Rig/CF2-Canvas/CF2-Panel/")).GetComponent<PanelManager>();
if ((Object)(object)panelManager != (Object)null)
{
panelManager.EGADBAFHHEEABED = ((Component)gunMenu).gameObject;
}
Button[] Buttons = Il2CppArrayBase<Button>.op_Implicit(((Component)gunMenu).GetComponentsInChildren<Button>());
Button[] array = Buttons;
foreach (Button button in array)
{
((Selectable)button).interactable = true;
}
if (ACKill.gameMode.ToLower().Contains("pvp"))
{
Transform weaponHolder = localPlayer.transform.Find("player/CamHolder (OBD)/Shaker/Camera/InventoryMaster/weaponHolder/");
if ((Object)(object)weaponHolder != (Object)null)
{
ToolGun[] toolGuns = Il2CppArrayBase<ToolGun>.op_Implicit(((Component)weaponHolder).GetComponentsInChildren<ToolGun>(true));
if (toolGuns.Length > 1)
{
for (int i = 1; i < toolGuns.Length; i++)
{
Object.Destroy((Object)(object)((Component)toolGuns[i]).gameObject);
}
}
else if (toolGuns.Length == 0)
{
((Component)gameMaster).gameObject.GetComponent<GameMaster>().GiveWeapon("ToolGun");
}
}
}
}
}
yield return (object)new WaitForSeconds(1f);
}
}
private void HandleCheats()
{
//IL_0095: 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_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_0211: Unknown result type (might be due to invalid IL or missing references)
//IL_022e: Unknown result type (might be due to invalid IL or missing references)
//IL_0249: Unknown result type (might be due to invalid IL or missing references)
//IL_026e: Unknown result type (might be due to invalid IL or missing references)
//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
if (ui.forceHost != 0)
{
Bypass.hostPerms = true;
if (ui.forceHost == ForceHostMode.Server)
{
Bypass.ForceHost();
}
if ((Object)(object)gameMaster != (Object)null && !gameMaster.DGBBDEFFHFFHGDG.fakeValue)
{
gameMaster.DGBBDEFFHFFHGDG = new ObscuredBool(true);
}
}
else if (ui.forceHost == ForceHostMode.Off)
{
Bypass.hostPerms = false;
}
if (ObscuredBool.op_Implicit(PhotonNetwork.LocalPlayer.IsMasterClient) || Bypass.hostPerms)
{
ServerPanel component = ((Component)gameMaster).gameObject.GetComponent<ServerPanel>();
List<PlayerInfo> fFCBDHCCDDGGAFD = component.FFCBDHCCDDGGAFD;
Enumerator<PlayerInfo> enumerator = fFCBDHCCDDGGAFD.GetEnumerator();
while (enumerator.MoveNext())
{
PlayerInfo current = enumerator.Current;
foreach (Button componentsInChild in ((Component)current).GetComponentsInChildren<Button>(true))
{
((Component)componentsInChild).gameObject.SetActive(true);
if (Object.op_Implicit((Object)(object)((Component)componentsInChild).gameObject.GetComponent<EditorOnly>()))
{
((Behaviour)((Component)componentsInChild).gameObject.GetComponent<EditorOnly>()).enabled = false;
}
}
}
}
if (ui.deviceSpoof || Bypass.spoofID)
{
PhotonNetwork.LocalPlayer.UserId = Bypass.randomID;
}
if (!ui.noReload && !ui.rapidFire && !ui.noSpread && !ui.maxDamage)
{
return;
}
Il2CppArrayBase<GBWeapon> componentsInChildren = ((Component)localPlayer.transform.Find("player/CamHolder (OBD)/Shaker/Camera/InventoryMaster/weaponHolder")).GetComponentsInChildren<GBWeapon>();
foreach (GBWeapon item in componentsInChildren)
{
if (ui.noReload && item.DBAFBCFGBBFFFGD.fakeValue != 1)
{
item.DBAFBCFGBBFFFGD = new ObscuredInt(1);
}
if (ui.rapidFire && item.GAEHFCCEBEFEGBD.fakeValue != 100f)
{
item.GAEHFCCEBEFEGBD = new ObscuredFloat(100f);
item.AAEBCHDAFEAHDFB = 100f;
}
if (ui.noSpread && item.EEGGHFDAGAAADDC != 0f)
{
item.EEGGHFDAGAAADDC = 0f;
}
if (ui.maxDamage && item.CBAEBCCGDHBHHFB != 500f)
{
item.CBAEBCCGDHBHHFB = 500f;
item.GHFFFCHGFHBFHDA = new ObscuredFloat(500f);
item.GHECDEBDEADEDAC = 500f;
}
}
}
private void InitializeStyles()
{
//IL_0010: 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)
//IL_001e: 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)
//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_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Expected O, but got Unknown
//IL_0043: Expected O, but got Unknown
//IL_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: 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_0069: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_0080: Expected O, but got Unknown
//IL_0086: Expected O, but got Unknown
if (labelStyleVisible == null)
{
labelStyleVisible = new GUIStyle
{
fontSize = 14,
fontStyle = (FontStyle)0,
normal = new GUIStyleState
{
textColor = Color.red
}
};
}
if (labelStyleInvisible == null)
{
labelStyleInvisible = new GUIStyle
{
fontSize = 14,
fontStyle = (FontStyle)0,
normal = new GUIStyleState
{
textColor = Color.grey
}
};
}
}
private void DrawFovCircle()
{
//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_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: 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_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
Vector2 val = default(Vector2);
((Vector2)(ref val))..ctor((float)Screen.width / 2f, (float)Screen.height / 2f);
Color color = GUI.color;
GUI.color = Color.green;
Vector2 val2 = default(Vector2);
for (float num = 0f; num < 360f; num += 1f)
{
float num2 = num * ((float)Math.PI / 180f);
((Vector2)(ref val2))..ctor(val.x + Mathf.Cos(num2) * fovRadius, val.y + Mathf.Sin(num2) * fovRadius);
GUI.DrawTexture(new Rect(val2.x, val2.y, 1f, 1f), (Texture)(object)Texture2D.whiteTexture);
}
GUI.color = color;
}
private void IdentifyLocalPlayer()
{
//IL_003c: 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 ((Object)(object)localPlayer != (Object)null && localPlayer.activeSelf && localPlayer.GetComponent<PhotonView>().Owner != null)
{
return;
}
Scene activeScene = SceneManager.GetActiveScene();
foreach (PlayerMaster item in ((IEnumerable<GameObject>)((Scene)(ref activeScene)).GetRootGameObjects()).SelectMany((GameObject root) => (IEnumerable<PlayerMaster>)root.GetComponentsInChildren<PlayerMaster>(true)))
{
if ((Object)(object)item != (Object)null && ((Component)item).gameObject.activeSelf && !playerNameRegex.IsMatch(((Object)item).name) && ((Component)item).GetComponent<PhotonView>().Owner == PhotonNetwork.LocalPlayer)
{
localPlayer = ((Component)item).gameObject;
Bypass.localPlayer = ((Component)item).gameObject;
return;
}
}
localPlayer = null;
}
private void LocateCamera()
{
if ((Object)(object)gameCamera != (Object)null && ((Behaviour)gameCamera).isActiveAndEnabled)
{
return;
}
if ((Object)(object)localPlayer != (Object)null)
{
Transform val = localPlayer.transform.Find("player/CamHolder (OBD)/Shaker/Camera");
if ((Object)(object)val != (Object)null)
{
gameCamera = ((Component)val).GetComponent<Camera>();
if ((Object)(object)gameCamera != (Object)null)
{
return;
}
}
}
gameCamera = null;
}
private void HandleAimbot()
{
if (ui.aimbotMode != 0 && Input.GetMouseButton(1))
{
GameObject val = FindTargetClosestToScreenCenter();
if ((Object)(object)val != (Object)null)
{
AimAtTarget(val);
}
}
}
private void UpdateESPLabels()
{
//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
//IL_00c8: 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_00dd: Unknown result type (might be due to invalid IL or missing references)
//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
//IL_0146: Unknown result type (might be due to invalid IL or missing references)
//IL_0153: Unknown result type (might be due to invalid IL or missing references)
//IL_015b: Unknown result type (might be due to invalid IL or missing references)
//IL_0108: Unknown result type (might be due to invalid IL or missing references)
//IL_0116: Unknown result type (might be due to invalid IL or missing references)
labelsToRender.Clear();
if ((Object)(object)gameCamera == (Object)null || (Object)(object)localPlayer == (Object)null)
{
return;
}
foreach (PlayerMaster player in playerList)
{
if ((Object)(object)player == (Object)null || (Object)(object)((Component)player).gameObject == (Object)(object)localPlayer || !playerNameRegex.IsMatch(((Object)player).name))
{
continue;
}
Transform val = ((Component)player).gameObject.transform.Find("player/BaseAI/Armature/Model/Motion/B_Pelvis/B_Spine/B_Spine1/B_Spine2/B_Neck/B_Head");
if ((Object)(object)val != (Object)null)
{
Vector3 val2 = gameCamera.WorldToScreenPoint(val.position);
bool item = CheckVisibility(((Component)player).gameObject);
if (val2.z > 0f && val2.x >= 0f && val2.x <= (float)Screen.width && val2.y >= 0f && val2.y <= (float)Screen.height)
{
string playerNickname = GetPlayerNickname(((Component)player).gameObject);
labelsToRender.Add((new Vector3(val2.x, (float)Screen.height - val2.y), playerNickname, item));
}
}
}
}
private GameObject FindTargetClosestToScreenCenter()
{
//IL_00da: Unknown result type (might be due to invalid IL or missing references)
//IL_00df: Unknown result type (might be due to invalid IL or missing references)
//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
//IL_0104: Unknown result type (might be due to invalid IL or missing references)
//IL_0111: Unknown result type (might be due to invalid IL or missing references)
//IL_011e: Unknown result type (might be due to invalid IL or missing references)
//IL_011f: Unknown result type (might be due to invalid IL or missing references)
float num = fovRadius;
GameObject result = null;
if ((Object)(object)gameCamera == (Object)null)
{
return null;
}
Vector2 val = default(Vector2);
((Vector2)(ref val))..ctor((float)Screen.width / 2f, (float)Screen.height / 2f);
Vector2 val4 = default(Vector2);
foreach (PlayerMaster player in playerList)
{
if ((Object)(object)player == (Object)null || (Object)(object)((Component)player).gameObject == (Object)(object)localPlayer || !playerNameRegex.IsMatch(((Object)player).name))
{
continue;
}
Transform val2 = ((Component)player).gameObject.transform.Find("player/BaseAI/Armature/Model/Motion/B_Pelvis/B_Spine/B_Spine1/B_Spine2/B_Neck/B_Head");
if (!((Object)(object)val2 != (Object)null))
{
continue;
}
Vector3 val3 = gameCamera.WorldToScreenPoint(val2.position);
if (CheckVisibility(((Component)player).gameObject))
{
((Vector2)(ref val4))..ctor(val3.x, (float)Screen.height - val3.y);
float num2 = Vector2.Distance(val, val4);
if (!(num2 > fovRadius) && num2 < num)
{
num = num2;
result = ((Component)val2).gameObject;
}
}
}
return result;
}
private void AimAtTarget(GameObject target)
{
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: 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_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: 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)
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: 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_00a7: Unknown result type (might be due to invalid IL or missing references)
//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
//IL_014b: Unknown result type (might be due to invalid IL or missing references)
//IL_0150: Unknown result type (might be due to invalid IL or missing references)
//IL_015f: Unknown result type (might be due to invalid IL or missing references)
//IL_0164: Unknown result type (might be due to invalid IL or missing references)
//IL_0168: Unknown result type (might be due to invalid IL or missing references)
//IL_0172: Unknown result type (might be due to invalid IL or missing references)
//IL_017e: Unknown result type (might be due to invalid IL or missing references)
//IL_0196: Unknown result type (might be due to invalid IL or missing references)
//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)target == (Object)null || (Object)(object)gameCamera == (Object)null || (Object)(object)localPlayer == (Object)null)
{
return;
}
Vector3 position = target.transform.position;
Vector3 val = position - ((Component)gameCamera).transform.position;
Vector3 normalized = ((Vector3)(ref val)).normalized;
Quaternion rotation = Quaternion.LookRotation(normalized);
if (ui.aimbotMode == AimbotMode.Silent)
{
((Component)gameCamera).transform.rotation = rotation;
}
else
{
if (ui.aimbotMode != AimbotMode.Normal)
{
return;
}
float num = Mathf.Atan2(normalized.x, normalized.z) * 57.29578f;
float num2 = Mathf.Asin(normalized.y) * 57.29578f;
num2 = Mathf.Clamp(num2, -75f, 65f);
Transform val2 = localPlayer.transform.Find("player");
if (!((Object)(object)val2 != (Object)null))
{
return;
}
RigidbodyFirstPersonController component = ((Component)val2).GetComponent<RigidbodyFirstPersonController>();
if ((Object)(object)component != (Object)null)
{
MouseLook val3 = ReflectionHelper.FindVariableByType<MouseLook>(component);
if (val3 != null)
{
Quaternion characterTargetRot = Quaternion.Euler(0f, num, 0f);
Quaternion cameraTargetRot = Quaternion.Euler(0f - num2, 0f, 0f);
val3.m_CharacterTargetRot = characterTargetRot;
val3.m_CameraTargetRot = cameraTargetRot;
val2.localRotation = val3.m_CharacterTargetRot;
((Component)gameCamera).transform.localRotation = val3.m_CameraTargetRot;
((Component)gameCamera).transform.rotation = rotation;
}
}
}
}
private bool CheckVisibility(GameObject player)
{
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_0080: 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_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_00b2: Unknown result type (might be due to invalid IL or missing references)
//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)gameCamera == (Object)null || (Object)(object)localPlayer == (Object)null || (Object)(object)player == (Object)null)
{
return false;
}
Collider[] array = Il2CppArrayBase<Collider>.op_Implicit(player.GetComponentsInChildren<Collider>());
if (array == null || array.Length == 0)
{
return false;
}
Vector3 val = ((Component)gameCamera).transform.position + ((Component)gameCamera).transform.forward * 0.5f;
Collider[] array2 = array;
RaycastHit val4 = default(RaycastHit);
foreach (Collider val2 in array2)
{
if (!((Object)(object)val2 == (Object)null))
{
Bounds bounds = val2.bounds;
Vector3 val3 = ((Bounds)(ref bounds)).center - val;
float magnitude = ((Vector3)(ref val3)).magnitude;
if (Physics.Raycast(val, val3, ref val4, magnitude) && (Object)(object)((RaycastHit)(ref val4)).collider == (Object)(object)val2)
{
return true;
}
}
}
return false;
}
private string GetPlayerNickname(GameObject player)
{
if ((Object)(object)player == (Object)null)
{
return "Unknown";
}
PhotonView component = player.GetComponent<PhotonView>();
return ((Object)(object)component != (Object)null) ? component.Owner.NickName : "Unknown";
}
}
public static class LoginProxy
{
private static readonly HttpClientHandler httpClientHandler = new HttpClientHandler
{
Proxy = new WebProxy("http://130.162.180.254:8888"),
UseProxy = true
};
private static HttpClient httpClient = new HttpClient();
public static string PlayfabPost(CallRequestContainer reqContainer, bool useProxy = false)
{
//IL_003b: 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_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Expected O, but got Unknown
//IL_0058: Expected O, but got Unknown
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Expected O, but got Unknown
try
{
string @string = Encoding.UTF8.GetString(Il2CppArrayBase<byte>.op_Implicit((Il2CppArrayBase<byte>)(object)reqContainer.Payload));
if (useProxy)
{
httpClient = new HttpClient((HttpMessageHandler)(object)httpClientHandler);
}
HttpRequestMessage val = new HttpRequestMessage(HttpMethod.Post, reqContainer.FullUrl)
{
Content = (HttpContent)new StringContent(@string, Encoding.UTF8, "application/json")
};
Enumerator<string, string> enumerator = reqContainer.RequestHeaders.GetEnumerator();
while (enumerator.MoveNext())
{
KeyValuePair<string, string> current = enumerator.Current;
if (!string.IsNullOrEmpty(current.Key) && !string.IsNullOrEmpty(current.Value))
{
((HttpHeaders)val.Headers).TryAddWithoutValidation(current.Key, current.Value);
}
}
HttpResponseMessage result = httpClient.SendAsync(val).Result;
return result.Content.ReadAsStringAsync().Result;
}
catch (Exception ex)
{
Debug.Log(Object.op_Implicit("Error in LoginProxyAndroidID: " + ex.Message));
return null;
}
}
}
public enum AimbotMode
{
Off,
Normal,
Silent
}
public enum ForceHostMode
{
Off,
Client,
Server
}
public enum BadgeSpoof
{
Off,
Empty,
Developer
}
public class UI
{
public bool showUI = true;
public AimbotMode aimbotMode = AimbotMode.Off;
public bool isESPEnabled = false;
public bool deviceSpoof = false;
public bool noReload = false;
public bool rapidFire = false;
public bool noSpread = false;
public bool maxDamage = false;
public ForceHostMode forceHost = ForceHostMode.Off;
public bool antiKick = false;
public bool antiMod = false;
public bool bigExplosives = false;
public BadgeSpoof badgeSpoof = BadgeSpoof.Off;
private UIStyle style;
public void Start()
{
LoadPreferences();
InitializeStyle();
}
public void Update()
{
if (Bypass.banned)
{
deviceSpoof = true;
Bypass.spoofID = true;
}
else
{
Bypass.spoofID = deviceSpoof;
}
Bypass.antiKick = antiKick;
Bypass.antiMod = antiMod;
Bypass.devBadge = badgeSpoof == BadgeSpoof.Developer;
Bypass.bigExplosive = bigExplosives;
}
public void OnGUI()
{
//IL_007d: Unknown result type (might be due to invalid IL or missing references)
//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
//IL_014f: Unknown result type (might be due to invalid IL or missing references)
//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
//IL_024f: Unknown result type (might be due to invalid IL or missing references)
//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
//IL_0354: Unknown result type (might be due to invalid IL or missing references)
//IL_03ab: Unknown result type (might be due to invalid IL or missing references)
if (showUI)
{
if (style == null || IsStyleBroken())
{
InitializeStyle();
}
GUI.Box(new Rect(((Rect)(ref style.posRect)).x, ((Rect)(ref style.posRect)).y + 0f, style.widthSize + 10f, 50f + (float)(45 * style.mulY)), "", style.BgStyle);
GUI.Label(new Rect(((Rect)(ref style.posRect)).x, ((Rect)(ref style.posRect)).y + 5f, style.widthSize + 10f, 95f), "GoreBox Menu\nIndica", style.LabelStyle);
if (GUI.Button(style.BtnRect(), "Aimbot" + GetAimbotModeText(), (aimbotMode != 0) ? style.OnStyle : style.OffStyle))
{
CycleAimbotMode();
SavePreferences();
}
if (GUI.Button(style.BtnRect(2), "ESP", isESPEnabled ? style.OnStyle : style.OffStyle))
{
isESPEnabled = !isESPEnabled;
SavePreferences();
}
if (GUI.Button(style.BtnRect(3), "No Reload", noReload ? style.OnStyle : style.OffStyle))
{
noReload = !noReload;
SavePreferences();
}
if (GUI.Button(style.BtnRect(4), "Rapid Fire", rapidFire ? style.OnStyle : style.OffStyle))
{
rapidFire = !rapidFire;
SavePreferences();
}
if (GUI.Button(style.BtnRect(5), "No Spread", noSpread ? style.OnStyle : style.OffStyle))
{
noSpread = !noSpread;
SavePreferences();
}
if (GUI.Button(style.BtnRect(6), "Max Damage", maxDamage ? style.OnStyle : style.OffStyle))
{
maxDamage = !maxDamage;
SavePreferences();
}
if (GUI.Button(style.BtnRect(7), "Force Host" + GetForceHostText(), (forceHost != 0) ? style.OnStyle : style.OffStyle))
{
CycleForceHostMode();
SavePreferences();
}
if (GUI.Button(style.BtnRect(8), "Big Bombs", bigExplosives ? style.OnStyle : style.OffStyle))
{
bigExplosives = !bigExplosives;
SavePreferences();
}
if (GUI.Button(style.BtnRect(9), "Close", style.BtnStyle))
{
showUI = false;
}
}
}
private void InitializeStyle()
{
style = new UIStyle();
style.Start();
}
private bool IsStyleBroken()
{
return IsNullOrBackgroundMissing(style.BgStyle) || IsNullOrBackgroundMissing(style.BtnStyle) || IsNullOrBackgroundMissing(style.OnStyle) || IsNullOrBackgroundMissing(style.OffStyle);
}
private bool IsNullOrBackgroundMissing(GUIStyle style)
{
return style == null || (Object)(object)style.normal.background == (Object)null;
}
private void CycleAimbotMode()
{
aimbotMode++;
if (aimbotMode == (AimbotMode)3)
{
aimbotMode = AimbotMode.Off;
}
}
private void CycleForceHostMode()
{
forceHost++;
if (forceHost == (ForceHostMode)3)
{
forceHost = ForceHostMode.Off;
}
}
private void CycleBadgeSpoofMode()
{
badgeSpoof++;
if (badgeSpoof == (BadgeSpoof)3)
{
badgeSpoof = BadgeSpoof.Off;
}
}
private string GetAimbotModeText()
{
return aimbotMode switch
{
AimbotMode.Off => string.Empty,
AimbotMode.Normal => " (N)",
AimbotMode.Silent => " (S)",
_ => string.Empty,
};
}
private string GetForceHostText()
{
return forceHost switch
{
ForceHostMode.Off => string.Empty,
ForceHostMode.Client => " (C)",
ForceHostMode.Server => " (S)",
_ => string.Empty,
};
}
private string GetBadgeModeText()
{
return badgeSpoof switch
{
BadgeSpoof.Off => string.Empty,
BadgeSpoof.Empty => " (E)",
BadgeSpoof.Developer => " (D)",
_ => string.Empty,
};
}
private void SavePreferences()
{
PlayerPrefs.SetInt("AimbotMode", (int)aimbotMode);
PlayerPrefs.SetInt("IsESPEnabled", isESPEnabled ? 1 : 0);
PlayerPrefs.SetInt("NoReload", noReload ? 1 : 0);
PlayerPrefs.SetInt("RapidFire", rapidFire ? 1 : 0);
PlayerPrefs.SetInt("NoSpread", noSpread ? 1 : 0);
PlayerPrefs.SetInt("MaxDamage", maxDamage ? 1 : 0);
PlayerPrefs.SetInt("ForceHost", (int)forceHost);
PlayerPrefs.SetInt("BigBombs", bigExplosives ? 1 : 0);
PlayerPrefs.Save();
}
private void LoadPreferences()
{
aimbotMode = (AimbotMode)PlayerPrefs.GetInt("AimbotMode", 0);
isESPEnabled = PlayerPrefs.GetInt("IsESPEnabled", 0) == 1;
noReload = PlayerPrefs.GetInt("NoReload", 0) == 1;
rapidFire = PlayerPrefs.GetInt("RapidFire", 0) == 1;
noSpread = PlayerPrefs.GetInt("NoSpread", 0) == 1;
maxDamage = PlayerPrefs.GetInt("MaxDamage", 0) == 1;
forceHost = (ForceHostMode)PlayerPrefs.GetInt("ForceHost", 0);
bigExplosives = PlayerPrefs.GetInt("BigBombs", 0) == 1;
}
}
public class UIStyle
{
public GUIStyle BgStyle;
public GUIStyle OnStyle;
public GUIStyle OffStyle;
public GUIStyle LabelStyle;
public GUIStyle BtnStyle;
public GUIStyle BtnStyle1;
public GUIStyle BtnStyle2;
public GUIStyle BtnStyle3;
public float delay = 0f;
public float widthSize = 300f;
public Texture2D ontexture;
public Texture2D onpresstexture;
public Texture2D offtexture;
public Texture2D offpresstexture;
public Texture2D backtexture;
public Texture2D btntexture;
public Texture2D btnpresstexture;
public Rect posRect = new Rect(0f, 150f, 0f, 0f);
public int btnY;
public int mulY;
public int btnX;
public int mulX;
public Texture2D NewTexture2D => new Texture2D(1, 1);
public Texture2D BtnTexture
{
get
{
//IL_0034: 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)
if ((Object)(object)btntexture == (Object)null)
{
btntexture = NewTexture2D;
btntexture.SetPixel(0, 0, Color32.op_Implicit(new Color32((byte)106, (byte)27, (byte)154, byte.MaxValue)));
btntexture.Apply();
}
return btntexture;
}
}
public Texture2D BtnPressTexture
{
get
{
//IL_0034: 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)
if ((Object)(object)btnpresstexture == (Object)null)
{
btnpresstexture = NewTexture2D;
btnpresstexture.SetPixel(0, 0, Color32.op_Implicit(new Color32((byte)123, (byte)31, (byte)162, byte.MaxValue)));
btnpresstexture.Apply();
}
return btnpresstexture;
}
}
public Texture2D OnPressTexture
{
get
{
//IL_0034: 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)
if ((Object)(object)onpresstexture == (Object)null)
{
onpresstexture = NewTexture2D;
onpresstexture.SetPixel(0, 0, Color32.op_Implicit(new Color32((byte)56, (byte)142, (byte)60, byte.MaxValue)));
onpresstexture.Apply();
}
return onpresstexture;
}
}
public Texture2D OnTexture
{
get
{
//IL_0034: 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)
if ((Object)(object)ontexture == (Object)null)
{
ontexture = NewTexture2D;
ontexture.SetPixel(0, 0, Color32.op_Implicit(new Color32((byte)76, (byte)175, (byte)80, byte.MaxValue)));
ontexture.Apply();
}
return ontexture;
}
}
public Texture2D OffPressTexture
{
get
{
//IL_0034: 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)
if ((Object)(object)offpresstexture == (Object)null)
{
offpresstexture = NewTexture2D;
offpresstexture.SetPixel(0, 0, Color32.op_Implicit(new Color32((byte)211, (byte)47, (byte)47, byte.MaxValue)));
offpresstexture.Apply();
}
return offpresstexture;
}
}
public Texture2D OffTexture
{
get
{
//IL_0034: 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)
if ((Object)(object)offtexture == (Object)null)
{
offtexture = NewTexture2D;
offtexture.SetPixel(0, 0, Color32.op_Implicit(new Color32((byte)244, (byte)67, (byte)54, byte.MaxValue)));
offtexture.Apply();
}
return offtexture;
}
}
public Texture2D BackTexture
{
get
{
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)backtexture == (Object)null)
{
backtexture = NewTexture2D;
backtexture.SetPixel(0, 0, Color32.op_Implicit(new Color32((byte)42, (byte)42, (byte)42, (byte)200)));
backtexture.Apply();
}
return backtexture;
}
}
public Rect BtnRect(int y = 1, int x = 1, bool multiplyBtn = false)
{
//IL_00c8: 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_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
mulY = y;
mulX = x;
int num = 1;
if (x >= 2)
{
for (int i = 1; i < x; i++)
{
num += (int)widthSize + 20;
}
}
if (multiplyBtn)
{
btnY = 5 + 45 * y;
return new Rect(((Rect)(ref posRect)).x + (float)(5 * x), ((Rect)(ref posRect)).y + 5f + (float)(45 * y), widthSize - 90f, 40f);
}
return new Rect(((Rect)(ref posRect)).x + 4f + (float)num, ((Rect)(ref posRect)).y + 5f + (float)(45 * y), widthSize, 40f);
}
public void Start()
{
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Expected O, but got Unknown
//IL_0084: Unknown result type (might be due to invalid IL or missing references)
//IL_009a: Unknown result type (might be due to invalid IL or missing references)
//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
//IL_010c: Unknown result type (might be due to invalid IL or missing references)
//IL_0116: Expected O, but got Unknown
//IL_0121: Unknown result type (might be due to invalid IL or missing references)
//IL_0137: Unknown result type (might be due to invalid IL or missing references)
//IL_014d: Unknown result type (might be due to invalid IL or missing references)
//IL_0163: Unknown result type (might be due to invalid IL or missing references)
//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
//IL_01b3: Expected O, but got Unknown
//IL_021a: Unknown result type (might be due to invalid IL or missing references)
//IL_0230: Unknown result type (might be due to invalid IL or missing references)
//IL_0246: Unknown result type (might be due to invalid IL or missing references)
//IL_025c: Unknown result type (might be due to invalid IL or missing references)
//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
//IL_02ac: Expected O, but got Unknown
//IL_0313: Unknown result type (might be due to invalid IL or missing references)
//IL_0329: Unknown result type (might be due to invalid IL or missing references)
//IL_033f: Unknown result type (might be due to invalid IL or missing references)
//IL_0355: Unknown result type (might be due to invalid IL or missing references)
//IL_039d: Unknown result type (might be due to invalid IL or missing references)
//IL_03a7: Expected O, but got Unknown
//IL_040e: Unknown result type (might be due to invalid IL or missing references)
//IL_0424: Unknown result type (might be due to invalid IL or missing references)
//IL_043a: Unknown result type (might be due to invalid IL or missing references)
//IL_0450: Unknown result type (might be due to invalid IL or missing references)
if (BgStyle == null)
{
BgStyle = new GUIStyle();
BgStyle.normal.background = BackTexture;
BgStyle.onNormal.background = BackTexture;
BgStyle.active.background = BackTexture;
BgStyle.onActive.background = BackTexture;
BgStyle.normal.textColor = Color.white;
BgStyle.onNormal.textColor = Color.white;
BgStyle.active.textColor = Color.white;
BgStyle.onActive.textColor = Color.white;
BgStyle.fontSize = 18;
BgStyle.fontStyle = (FontStyle)0;
BgStyle.alignment = (TextAnchor)1;
}
if (LabelStyle == null)
{
LabelStyle = new GUIStyle();
LabelStyle.normal.textColor = Color.white;
LabelStyle.onNormal.textColor = Color.white;
LabelStyle.active.textColor = Color.white;
LabelStyle.onActive.textColor = Color.white;
LabelStyle.fontSize = 18;
LabelStyle.fontStyle = (FontStyle)0;
LabelStyle.alignment = (TextAnchor)1;
}
if (OffStyle == null)
{
OffStyle = new GUIStyle();
OffStyle.normal.background = OffTexture;
OffStyle.onNormal.background = OffTexture;
OffStyle.active.background = OffPressTexture;
OffStyle.onActive.background = OffPressTexture;
OffStyle.normal.textColor = Color.white;
OffStyle.onNormal.textColor = Color.white;
OffStyle.active.textColor = Color.white;
OffStyle.onActive.textColor = Color.white;
OffStyle.fontSize = 18;
OffStyle.fontStyle = (FontStyle)0;
OffStyle.alignment = (TextAnchor)4;
}
if (OnStyle == null)
{
OnStyle = new GUIStyle();
OnStyle.normal.background = OnTexture;
OnStyle.onNormal.background = OnTexture;
OnStyle.active.background = OnPressTexture;
OnStyle.onActive.background = OnPressTexture;
OnStyle.normal.textColor = Color.white;
OnStyle.onNormal.textColor = Color.white;
OnStyle.active.textColor = Color.white;
OnStyle.onActive.textColor = Color.white;
OnStyle.fontSize = 18;
OnStyle.fontStyle = (FontStyle)0;
OnStyle.alignment = (TextAnchor)4;
}
if (BtnStyle == null)
{
BtnStyle = new GUIStyle();
BtnStyle.normal.background = BtnTexture;
BtnStyle.onNormal.background = BtnTexture;
BtnStyle.active.background = BtnPressTexture;
BtnStyle.onActive.background = BtnPressTexture;
BtnStyle.normal.textColor = Color.white;
BtnStyle.onNormal.textColor = Color.white;
BtnStyle.active.textColor = Color.white;
BtnStyle.onActive.textColor = Color.white;
BtnStyle.fontSize = 18;
BtnStyle.fontStyle = (FontStyle)0;
BtnStyle.alignment = (TextAnchor)4;
}
}
}
}
