using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
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.RegularExpressions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using PluginConfig.API;
using PluginConfig.API.Decorators;
using PluginConfig.API.Fields;
using PluginConfig.API.Functionals;
using ULTRACHALLENGE.Utils;
using Unity.Mathematics;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.SceneManagement;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("ULTRACHALLENGE")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ULTRACHALLENGE")]
[assembly: AssemblyCopyright("Copyright © 2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("27261b9b-5345-4613-b8e3-b1f0dddd49b5")]
[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 class MathParser
{
public static float HandleComplexMath(string expression, float x, float sceneNumber = 0f)
{
try
{
expression = expression.Replace("x", x.ToString());
expression = expression.Replace("sceneNumber", sceneNumber.ToString());
List<string> tokens = Tokenize(expression);
int index = 0;
float num = ParseExpression(tokens, ref index);
Debug.Log((object)$"{expression} = {num}");
return num;
}
catch (Exception ex)
{
Debug.Log((object)("Error: " + ex.Message));
return 0f;
}
}
private static List<string> Tokenize(string expr)
{
List<string> list = new List<string>();
int num = 0;
while (num < expr.Length)
{
if (char.IsDigit(expr[num]) || expr[num] == '.')
{
string text = "";
while (num < expr.Length && (char.IsDigit(expr[num]) || expr[num] == '.'))
{
text += expr[num++];
}
list.Add(text);
}
else if (Enumerable.Contains("+-*/^()>?:", expr[num]))
{
list.Add(expr[num].ToString());
num++;
}
else if (char.IsLetter(expr[num]))
{
string text2 = "";
while (num < expr.Length && char.IsLetter(expr[num]))
{
text2 += expr[num++];
}
list.Add(text2);
}
else
{
num++;
}
}
return list;
}
private static float ParseExpression(List<string> tokens, ref int index)
{
return ParseConditional(tokens, ref index);
}
private static float ParseConditional(List<string> tokens, ref int index)
{
float num = ParseAddSub(tokens, ref index);
if (index < tokens.Count && tokens[index] == "?")
{
index++;
float num2 = ParseAddSub(tokens, ref index);
if (index >= tokens.Count || tokens[index] != ":")
{
throw new Exception("Expected ':' in conditional expression");
}
index++;
float num3 = ParseAddSub(tokens, ref index);
return (num > 0f) ? num2 : num3;
}
return num;
}
private static float ParseAddSub(List<string> tokens, ref int index)
{
float num = ParseMulDiv(tokens, ref index);
while (index < tokens.Count && (tokens[index] == "+" || tokens[index] == "-"))
{
string text = tokens[index++];
float num2 = ParseMulDiv(tokens, ref index);
num = ((text == "+") ? (num + num2) : (num - num2));
}
return num;
}
private static float ParseMulDiv(List<string> tokens, ref int index)
{
float num = ParseFactor(tokens, ref index);
while (index < tokens.Count && (tokens[index] == "*" || tokens[index] == "/"))
{
string text = tokens[index++];
float num2 = ParseFactor(tokens, ref index);
num = ((text == "*") ? (num * num2) : (num / num2));
}
return num;
}
private static float ParseFactor(List<string> tokens, ref int index)
{
float num = ParseBase(tokens, ref index);
while (index < tokens.Count && tokens[index] == "^")
{
index++;
float num2 = ParseFactor(tokens, ref index);
num = (float)Math.Pow(num, num2);
}
return num;
}
private static float ParseBase(List<string> tokens, ref int index)
{
if (tokens[index] == "-")
{
index++;
return 0f - ParseBase(tokens, ref index);
}
if (char.IsLetter(tokens[index][0]))
{
string text = tokens[index++];
if (tokens[index] != "(")
{
throw new Exception("Expected '(' after function name");
}
index++;
float num = ParseExpression(tokens, ref index);
if (tokens[index] != ")")
{
throw new Exception("Expected ')' after function argument");
}
index++;
return text switch
{
"log" => (float)Math.Log(num),
"sqrt" => (float)Math.Sqrt(num),
"sin" => (float)Math.Sin(num),
"cos" => (float)Math.Cos(num),
"tan" => (float)Math.Tan(num),
"rand" => Random.Range(0f, num),
_ => throw new Exception("Unknown function: " + text),
};
}
if (tokens[index] == "(")
{
index++;
float result = ParseExpression(tokens, ref index);
index++;
return result;
}
return float.Parse(tokens[index++]);
}
}
public class ResourceLoader
{
private const string ResourcePath = "ULTRACHALLENGE.TXTFiles.Resource_Locations.txt";
private const string PKeyPattern = "PKEY:\\s+(Assets/Prefabs/Attacks and Projectiles/Explosions/[^\\n]+)";
private const string RTypePattern = "RTYPE:\\s+UnityEngine.GameObject";
public static bool isDone;
public static Dictionary<string, GameObject> getExplosions(List<string> explosionKeys)
{
return LoadExplosions(explosionKeys);
}
public static List<string> GetExplosionPKeys()
{
List<string> list = new List<string>();
string text = LoadEmbeddedResource("ULTRACHALLENGE.TXTFiles.Resource_Locations.txt");
if (text == null)
{
Debug.LogError((object)"Failed to load embedded resource: ULTRACHALLENGE.TXTFiles.Resource_Locations.txt");
return list;
}
string[] array = text.Split(new string[1] { "==================================================" }, StringSplitOptions.RemoveEmptyEntries);
string[] array2 = array;
foreach (string input in array2)
{
if (Regex.IsMatch(input, "RTYPE:\\s+UnityEngine.GameObject"))
{
Match match = Regex.Match(input, "PKEY:\\s+(Assets/Prefabs/Attacks and Projectiles/Explosions/[^\\n]+)");
if (match.Success)
{
list.Add(match.Groups[1].Value.Trim());
}
}
}
return list;
}
private static Dictionary<string, GameObject> LoadExplosions(List<string> explosionKeys)
{
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
Dictionary<string, GameObject> toReturn = new Dictionary<string, GameObject>();
foreach (string key in explosionKeys)
{
AsyncOperationHandle<GameObject> val = Addressables.LoadAssetAsync<GameObject>((object)key);
val.Completed += delegate(AsyncOperationHandle<GameObject> handle)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Invalid comparison between Unknown and I4
if ((int)handle.Status == 1)
{
Debug.Log((object)("Loaded: " + key));
toReturn.Add(key.Replace("Assets/Prefabs/Attacks and Projectiles/Explosions/", ""), handle.Result);
}
else
{
Debug.LogError((object)("Failed to load: " + key));
}
};
}
isDone = true;
return toReturn;
}
private static string LoadEmbeddedResource(string resourceName)
{
try
{
Assembly executingAssembly = Assembly.GetExecutingAssembly();
using Stream stream = executingAssembly.GetManifestResourceStream(resourceName);
if (stream == null)
{
Debug.LogError((object)("Resource not found: " + resourceName));
return null;
}
using StreamReader streamReader = new StreamReader(stream);
return streamReader.ReadToEnd();
}
catch (Exception ex)
{
Debug.LogError((object)("Error loading embedded resource: " + ex.Message));
return null;
}
}
}
namespace ULTRACHALLENGE
{
[BepInPlugin("com.banana.ULTRACHALLENGE", "ULTRACHALLENGE", "1.0.0")]
public class ULTRACHALLENGEPlugin : BaseUnityPlugin
{
private const string MyGUID = "com.banana.ULTRACHALLENGE";
private const string PluginName = "ULTRACHALLENGE";
private const string VersionString = "1.0.0";
private static readonly Harmony Harmony = new Harmony("com.banana.ULTRACHALLENGE");
public static ManualLogSource Log = new ManualLogSource("ULTRACHALLENGE");
private PluginConfigurator config;
public static List<int> AlreadyUsedGUIDS = new List<int>();
public static List<ChallengeSetting> ChallengeSettings = new List<ChallengeSetting>();
public static List<string> explosions;
public static List<string> explosionNames = new List<string>();
public static Dictionary<string, GameObject> theExplosions = new Dictionary<string, GameObject>();
private float timer;
public float radiusForBlood = 2f;
public static string workingPath;
public static string workingDir;
private void Awake()
{
((BaseUnityPlugin)this).Logger.LogInfo((object)"PluginName: ULTRACHALLENGE, VersionString: 1.0.0 is loading...");
Harmony.PatchAll();
((BaseUnityPlugin)this).Logger.LogInfo((object)"PluginName: ULTRACHALLENGE, VersionString: 1.0.0 is loaded.");
workingPath = Assembly.GetExecutingAssembly().Location;
workingDir = Path.GetDirectoryName(workingPath);
Log = ((BaseUnityPlugin)this).Logger;
SetupChallengeThings();
explosions = ResourceLoader.GetExplosionPKeys();
explosions = explosions.Distinct().ToList();
theExplosions = ResourceLoader.getExplosions(explosions);
((MonoBehaviour)this).StartCoroutine(LoadExplosions());
SceneManager.sceneLoaded += SceneManager_sceneLoaded;
}
private IEnumerator LoadExplosions()
{
yield return (object)new WaitUntil((Func<bool>)(() => ResourceLoader.isDone));
foreach (KeyValuePair<string, GameObject> item in theExplosions)
{
Debug.Log((object)item.Key);
explosionNames.Add(item.Key);
}
Debug.Log((object)$"Final explosionNames count: {explosionNames.Count}");
}
private void Update()
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
//IL_022c: Unknown result type (might be due to invalid IL or missing references)
foreach (ChallengeSetting challengeSetting in ChallengeSettings)
{
if (challengeSetting.situation.value == TypeOfThing.OnUseInput && Input.GetKeyDown(challengeSetting.keyField.value))
{
Handlers.HandleThing(challengeSetting, ((Component)MonoSingleton<NewMovement>.Instance).transform);
}
if (challengeSetting.situation.value == TypeOfThing.EveryFewSeconds && timer > 0f)
{
timer -= Time.deltaTime;
}
else if (challengeSetting.situation.value == TypeOfThing.EveryFewSeconds)
{
timer = challengeSetting.numberField.value;
Handlers.HandleThing(challengeSetting, ((Component)MonoSingleton<NewMovement>.Instance).transform);
}
if (challengeSetting.situation.value == TypeOfThing.NearBlood && Handlers.IsBloodNearby(radiusForBlood))
{
if (challengeSetting.timer < challengeSetting.delayField.value)
{
challengeSetting.timer += Time.deltaTime;
}
if (challengeSetting.timer >= challengeSetting.delayField.value)
{
Handlers.HandleThing(challengeSetting, ((Component)MonoSingleton<NewMovement>.Instance).transform);
challengeSetting.timer = 0f;
}
}
}
foreach (ChallengeSetting challengeSetting2 in ChallengeSettings)
{
if (challengeSetting2.situation.value == TypeOfThing.OnUseInput && Input.GetKey(challengeSetting2.keyField.value) && challengeSetting2.WhileSituation.value)
{
if (challengeSetting2.timer >= challengeSetting2.delayField.value)
{
Handlers.HandleThing(challengeSetting2, ((Component)MonoSingleton<NewMovement>.Instance).transform);
challengeSetting2.timer = 0f;
}
else
{
challengeSetting2.timer += Time.deltaTime;
}
}
else if (!Input.GetKey(challengeSetting2.keyField.value))
{
challengeSetting2.timer = 0f;
}
}
foreach (ChallengeSetting challengeSetting3 in ChallengeSettings)
{
if (challengeSetting3.challengeType.value == challengeTypes.LinkProperties)
{
Handlers.setLinkables(challengeSetting3.Link1.value, challengeSetting3.Link2.value, challengeSetting3.Reversed.value, challengeSetting3.MultiplierField.value, challengeSetting3.OffsetField.value);
}
}
}
private void SceneManager_sceneLoaded(Scene arg0, LoadSceneMode arg1)
{
foreach (ChallengeSetting challengeSetting in ChallengeSettings)
{
if (challengeSetting.saveValue.value && challengeSetting.ValueAlreadySet)
{
switch (challengeSetting.whatShouldItDo.value)
{
case whatShouldHappen.Speed:
MonoSingleton<NewMovement>.Instance.walkSpeed = challengeSetting.savedValue;
break;
case whatShouldHappen.JumpPower:
MonoSingleton<NewMovement>.Instance.jumpPower = challengeSetting.savedValue;
break;
}
}
}
foreach (ChallengeSetting challengeSetting2 in ChallengeSettings)
{
if (challengeSetting2.situation.value == TypeOfThing.onSceneChange)
{
Handlers.HandleThing(challengeSetting2, ((Component)MonoSingleton<NewMovement>.Instance).transform);
}
}
}
public void SetupChallengeThings()
{
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_005c: Expected O, but got Unknown
//IL_0064: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Expected O, but got Unknown
config = PluginConfigurator.Create("ULTRA CHALLENGE", "com.banana.ULTRACHALLENGE");
string text = Path.Combine(workingDir, "icon.png");
if (File.Exists(text))
{
config.SetIconWithURL(text);
}
ButtonField val = new ButtonField(config.rootPanel, "Add new setting.", "button.add.new.setting");
val.onClick += new OnClick(AddNewChallenge_onClick);
}
private void AddNewChallenge_onClick()
{
ChallengeSettings.Add(new ChallengeSetting(ChallengeSettings.Count + 1, config.rootPanel));
}
}
public enum TypeOfThing
{
OnTouchColor,
OnTouchGameObject,
OnDash,
OnJump,
OnSlide,
OnUseInput,
onSceneChange,
EveryFewSeconds,
OnTakeDamage,
OnDeath,
OnWeaponSwitch,
OnHeal,
OnParry,
OnEnemyKill,
Punch,
Shoot,
OnPieceMove,
OnPieceCapture,
NearBlood,
OnEnemySpawn
}
public enum whatShouldHappen
{
Damage,
Speed,
JumpPower,
SpawnExplosion,
KillEnemy,
DupeEnemy,
BuffEnemy,
Pixelization,
FOV,
VertexWarping,
Gamma,
ChangeToRandomLevel,
ChangeLevel,
RestartLevel,
Framerate,
RemoveGameObject,
Gravity,
SpawnAddressable,
Quit,
RemoveTriggerer
}
public enum math
{
Increase,
Decrease,
Multiply,
Divide,
Complex,
Set
}
public enum distance
{
Closest,
Furthest,
Inbetween,
Random
}
public enum spawnLocation
{
triggerlocation,
player
}
public enum param
{
AString,
Number,
Color,
KeyCode
}
public enum challengeTypes
{
OnAction,
LinkProperties
}
public enum Linkable
{
Health,
Speed,
JumpHeight,
Pixelization,
FOV,
VertexWarping,
Gamma,
Velocity,
Sensitivity,
FrameRate,
Gravity,
Time,
Stamina
}
[Serializable]
public class ChallengeSetting
{
[Serializable]
public class situationEnum
{
public TypeOfThing situation;
public bool canDoWhile;
public bool justDelayNoWhile;
public List<param> requiredParams;
public situationEnum(TypeOfThing sit, List<param> theParams, bool canDoWhile = false, bool justDelayNoWhile = false)
{
situation = sit;
requiredParams = theParams;
this.canDoWhile = canDoWhile;
this.justDelayNoWhile = justDelayNoWhile;
}
}
[Serializable]
public class whatShouldHappenEnum
{
public whatShouldHappen shouldHappen;
public bool canSaveThroughLevels;
public bool canDoMath;
public whatShouldHappenEnum(whatShouldHappen sit, bool canMath, bool canDoSave)
{
shouldHappen = sit;
canDoMath = canMath;
canSaveThroughLevels = canDoSave;
}
}
private string GUID;
private int ID;
public FloatField Tolerance;
public FloatField MultiplierField;
public FloatField OffsetField;
public BoolField WhileSituation;
public BoolField Reversed;
public IntField amount;
public StringField amountComplexMath;
public StringField stringParam;
public StringField addressablePath;
public FloatField numberField;
public FloatField delayField;
public FloatField ChanceField;
public ColorField color;
public EnumField<TypeOfThing> situation;
public EnumField<challengeTypes> challengeType;
public EnumField<Linkable> Link1;
public EnumField<Linkable> Link2;
public EnumField<whatShouldHappen> whatShouldItDo;
public EnumField<spawnLocation> spawnLocation;
public EnumField<math> weDoALittleMath;
public EnumField<distance> distanceField;
public StringListField explosionList;
public KeyCodeField keyField;
public float timer;
public BoolField saveValue;
public float savedValue;
public bool ValueAlreadySet = false;
private ConfigHeader header;
public GameObject selectedExplosion = null;
private ButtonField removesetting;
public List<situationEnum> situationSettings = new List<situationEnum>
{
new situationEnum(TypeOfThing.OnTouchColor, new List<param> { param.Color }, canDoWhile: true),
new situationEnum(TypeOfThing.OnDash, new List<param>()),
new situationEnum(TypeOfThing.onSceneChange, new List<param>()),
new situationEnum(TypeOfThing.OnSlide, new List<param>()),
new situationEnum(TypeOfThing.OnJump, new List<param>()),
new situationEnum(TypeOfThing.OnUseInput, new List<param> { param.KeyCode }, canDoWhile: true),
new situationEnum(TypeOfThing.OnTouchGameObject, new List<param> { param.AString }, canDoWhile: true),
new situationEnum(TypeOfThing.EveryFewSeconds, new List<param> { param.Number }),
new situationEnum(TypeOfThing.OnTakeDamage, new List<param>()),
new situationEnum(TypeOfThing.OnDeath, new List<param>()),
new situationEnum(TypeOfThing.OnParry, new List<param>()),
new situationEnum(TypeOfThing.OnWeaponSwitch, new List<param>()),
new situationEnum(TypeOfThing.Punch, new List<param>()),
new situationEnum(TypeOfThing.Shoot, new List<param>()),
new situationEnum(TypeOfThing.NearBlood, new List<param>(), canDoWhile: false, justDelayNoWhile: true)
};
public List<whatShouldHappenEnum> whatShouldHappenSettings = new List<whatShouldHappenEnum>
{
new whatShouldHappenEnum(whatShouldHappen.Damage, canMath: false, canDoSave: false),
new whatShouldHappenEnum(whatShouldHappen.Speed, canMath: true, canDoSave: true),
new whatShouldHappenEnum(whatShouldHappen.JumpPower, canMath: true, canDoSave: true),
new whatShouldHappenEnum(whatShouldHappen.SpawnExplosion, canMath: false, canDoSave: false),
new whatShouldHappenEnum(whatShouldHappen.KillEnemy, canMath: false, canDoSave: false),
new whatShouldHappenEnum(whatShouldHappen.DupeEnemy, canMath: false, canDoSave: false),
new whatShouldHappenEnum(whatShouldHappen.BuffEnemy, canMath: false, canDoSave: false),
new whatShouldHappenEnum(whatShouldHappen.FOV, canMath: true, canDoSave: false),
new whatShouldHappenEnum(whatShouldHappen.Gamma, canMath: true, canDoSave: false),
new whatShouldHappenEnum(whatShouldHappen.Pixelization, canMath: true, canDoSave: false),
new whatShouldHappenEnum(whatShouldHappen.VertexWarping, canMath: true, canDoSave: false),
new whatShouldHappenEnum(whatShouldHappen.ChangeLevel, canMath: false, canDoSave: false),
new whatShouldHappenEnum(whatShouldHappen.ChangeToRandomLevel, canMath: false, canDoSave: false),
new whatShouldHappenEnum(whatShouldHappen.RestartLevel, canMath: false, canDoSave: false),
new whatShouldHappenEnum(whatShouldHappen.Framerate, canMath: true, canDoSave: false),
new whatShouldHappenEnum(whatShouldHappen.RemoveGameObject, canMath: false, canDoSave: false),
new whatShouldHappenEnum(whatShouldHappen.Gravity, canMath: true, canDoSave: false),
new whatShouldHappenEnum(whatShouldHappen.SpawnAddressable, canMath: false, canDoSave: false),
new whatShouldHappenEnum(whatShouldHappen.Quit, canMath: false, canDoSave: false),
new whatShouldHappenEnum(whatShouldHappen.RemoveTriggerer, canMath: false, canDoSave: false)
};
public ChallengeSetting(int ID, ConfigPanel panel)
{
GenerateGUID();
this.ID = ID;
GenerateSettings(panel);
}
private void GenerateGUID()
{
int num = 0;
do
{
num = Random.Range(0, int.MaxValue);
}
while (ULTRACHALLENGEPlugin.AlreadyUsedGUIDS.Contains(num));
ULTRACHALLENGEPlugin.AlreadyUsedGUIDS.Add(num);
GUID = num.ToString();
}
private void GenerateSettings(ConfigPanel panel)
{
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Expected O, but got Unknown
//IL_0083: Unknown result type (might be due to invalid IL or missing references)
//IL_008d: Expected O, but got Unknown
//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
//IL_00b0: Expected O, but got Unknown
//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
//IL_00d7: Expected O, but got Unknown
//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
//IL_00fe: Expected O, but got Unknown
//IL_011b: Unknown result type (might be due to invalid IL or missing references)
//IL_0125: Expected O, but got Unknown
//IL_0142: Unknown result type (might be due to invalid IL or missing references)
//IL_014c: Expected O, but got Unknown
//IL_0169: Unknown result type (might be due to invalid IL or missing references)
//IL_0173: Expected O, but got Unknown
//IL_018a: Unknown result type (might be due to invalid IL or missing references)
//IL_0190: Unknown result type (might be due to invalid IL or missing references)
//IL_019a: Expected O, but got Unknown
//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
//IL_01c0: Expected O, but got Unknown
//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
//IL_01e6: Expected O, but got Unknown
//IL_0200: Unknown result type (might be due to invalid IL or missing references)
//IL_020a: Expected O, but got Unknown
//IL_0269: Unknown result type (might be due to invalid IL or missing references)
//IL_0273: Expected O, but got Unknown
//IL_029b: Unknown result type (might be due to invalid IL or missing references)
//IL_02a5: Expected O, but got Unknown
//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
//IL_02e6: Expected O, but got Unknown
//IL_0346: Unknown result type (might be due to invalid IL or missing references)
//IL_0350: Expected O, but got Unknown
//IL_036d: Unknown result type (might be due to invalid IL or missing references)
//IL_0377: Expected O, but got Unknown
//IL_03d2: Unknown result type (might be due to invalid IL or missing references)
//IL_03dc: Expected O, but got Unknown
//IL_0441: Unknown result type (might be due to invalid IL or missing references)
//IL_044b: Expected O, but got Unknown
//IL_0459: Unknown result type (might be due to invalid IL or missing references)
//IL_0463: Expected O, but got Unknown
header = new ConfigHeader(panel, "Challenge setting " + ID, 24);
challengeType = new EnumField<challengeTypes>(panel, "Challenge Type", "challengetype.enum." + GUID, challengeTypes.OnAction, false);
situation = new EnumField<TypeOfThing>(panel, "Situation", "situation.enum." + GUID, TypeOfThing.OnTouchColor, false);
WhileSituation = new BoolField(panel, "While the situation", "color.tolerance." + GUID, false, false);
Reversed = new BoolField(panel, "Reversed", "reversed.bool." + GUID, false, false);
delayField = new FloatField(panel, "Delay", "delay.float." + GUID, 0f, false);
MultiplierField = new FloatField(panel, "Multiplier", "multiplier.float." + GUID, 1f, false);
ChanceField = new FloatField(panel, "Chance", "chance.float." + GUID, 100f, false);
OffsetField = new FloatField(panel, "Offset", "offset.float." + GUID, 0f, false);
Tolerance = new FloatField(panel, "Tolerance", "color.tolerance." + GUID, 0.5f, false);
color = new ColorField(panel, "Color", "color.color." + GUID, Color.green, false);
stringParam = new StringField(panel, "String", "string.string." + GUID, "%name%");
numberField = new FloatField(panel, "Number", "number.number." + GUID, 5f);
keyField = new KeyCodeField(panel, "Key", "key.keycode." + GUID, (KeyCode)119, false);
whatShouldItDo = new EnumField<whatShouldHappen>(panel, "What Should Happen", "whatshouldhappen.enum." + GUID, whatShouldHappen.Damage, false);
distanceField = new EnumField<distance>(panel, "Distance", "distance.enum." + GUID, distance.Closest, false);
saveValue = new BoolField(panel, "Save Value Through Levels", "save.value." + GUID, false, false);
explosionList = new StringListField(panel, "Explosions", "gameobjects.explosions." + GUID, ULTRACHALLENGEPlugin.explosionNames, ULTRACHALLENGEPlugin.explosionNames[0], false);
selectedExplosion = ULTRACHALLENGEPlugin.theExplosions[explosionList.value];
addressablePath = new StringField(panel, "Addressable", "addressable.string." + GUID, "Assets/Prefabs/Items/DevPlushies/DevPlushie (Hakita).prefab");
spawnLocation = new EnumField<spawnLocation>(panel, "Spawn Location", "spawnlocation.enum." + GUID, ULTRACHALLENGE.spawnLocation.player, false);
weDoALittleMath = new EnumField<math>(panel, "How should it happen", "math.enum." + GUID, math.Set, false);
amount = new IntField(panel, "Amount", "whatshouldhappen.amount." + GUID, 10, false);
amountComplexMath = new StringField(panel, "Math Amount", "whatshouldhappen.complexmathamount." + GUID, "x+10", false);
Link1 = new EnumField<Linkable>(panel, "Source", "link.1.enum." + GUID, Linkable.Health);
Link2 = new EnumField<Linkable>(panel, "Target", "link.2.enum." + GUID, Linkable.Speed);
removesetting = new ButtonField(panel, "Remove Setting", "button.remove.setting." + GUID);
SwitchEnum(TypeOfThing.OnTouchColor);
SwitchHappen(whatShouldHappen.Damage);
whatShouldItDo.onValueChange += WhatShouldItDo_onValueChange;
situation.onValueChange += Situation_onValueChange;
weDoALittleMath.onValueChange += WeDoALittleMath_onValueChange;
removesetting.onClick += new OnClick(ChallengeSetting_onClick);
explosionList.onValueChange += new StringListValueChangeEventDelegate(ExplosionList_onValueChange);
challengeType.onValueChange += ChallengeType_onValueChange;
challengeType.TriggerValueChangeEvent();
}
private void ChallengeType_onValueChange(EnumValueChangeEvent<challengeTypes> data)
{
((ConfigField)situation).hidden = true;
((ConfigField)Tolerance).hidden = true;
((ConfigField)color).hidden = true;
((ConfigField)whatShouldItDo).hidden = true;
((ConfigField)saveValue).hidden = true;
((ConfigField)weDoALittleMath).hidden = true;
((ConfigField)amount).hidden = true;
((ConfigField)amountComplexMath).hidden = true;
((ConfigField)keyField).hidden = true;
((ConfigField)explosionList).hidden = true;
((ConfigField)distanceField).hidden = true;
((ConfigField)WhileSituation).hidden = true;
((ConfigField)stringParam).hidden = true;
((ConfigField)numberField).hidden = true;
((ConfigField)Link1).hidden = true;
((ConfigField)Link2).hidden = true;
((ConfigField)Reversed).hidden = true;
((ConfigField)MultiplierField).hidden = true;
((ConfigField)OffsetField).hidden = true;
((ConfigField)addressablePath).hidden = true;
((ConfigField)ChanceField).hidden = true;
((ConfigField)delayField).hidden = true;
((ConfigField)spawnLocation).hidden = true;
if (data.value == challengeTypes.OnAction)
{
SwitchEnum(situation.value);
SwitchHappen(whatShouldItDo.value);
((ConfigField)whatShouldItDo).hidden = false;
((ConfigField)situation).hidden = false;
((ConfigField)ChanceField).hidden = false;
}
else
{
((ConfigField)Link1).hidden = false;
((ConfigField)Link2).hidden = false;
((ConfigField)Reversed).hidden = false;
((ConfigField)MultiplierField).hidden = false;
((ConfigField)OffsetField).hidden = false;
}
}
private void ExplosionList_onValueChange(StringListValueChangeEvent data)
{
selectedExplosion = ULTRACHALLENGEPlugin.theExplosions[data.value];
}
private void ChallengeSetting_onClick()
{
((ConfigField)header).hidden = true;
((ConfigField)challengeType).hidden = true;
((ConfigField)situation).hidden = true;
((ConfigField)Tolerance).hidden = true;
((ConfigField)color).hidden = true;
((ConfigField)whatShouldItDo).hidden = true;
((ConfigField)saveValue).hidden = true;
((ConfigField)weDoALittleMath).hidden = true;
((ConfigField)amount).hidden = true;
((ConfigField)amountComplexMath).hidden = true;
((ConfigField)removesetting).hidden = true;
((ConfigField)keyField).hidden = true;
((ConfigField)explosionList).hidden = true;
((ConfigField)distanceField).hidden = true;
((ConfigField)WhileSituation).hidden = true;
((ConfigField)stringParam).hidden = true;
((ConfigField)Link1).hidden = true;
((ConfigField)Link2).hidden = true;
((ConfigField)Reversed).hidden = true;
((ConfigField)MultiplierField).hidden = true;
((ConfigField)OffsetField).hidden = true;
((ConfigField)addressablePath).hidden = true;
((ConfigField)ChanceField).hidden = true;
((ConfigField)delayField).hidden = true;
((ConfigField)spawnLocation).hidden = true;
ULTRACHALLENGEPlugin.ChallengeSettings.Remove(this);
for (int i = 0; i < ULTRACHALLENGEPlugin.ChallengeSettings.Count; i++)
{
ULTRACHALLENGEPlugin.ChallengeSettings[i].ResetID(i + 1);
}
}
private void WeDoALittleMath_onValueChange(EnumValueChangeEvent<math> data)
{
if (data.value == math.Complex)
{
((ConfigField)amountComplexMath).hidden = false;
}
else
{
((ConfigField)amountComplexMath).hidden = true;
}
}
private void Situation_onValueChange(EnumValueChangeEvent<TypeOfThing> data)
{
SwitchEnum(data.value);
}
private void WhatShouldItDo_onValueChange(EnumValueChangeEvent<whatShouldHappen> data)
{
SwitchHappen(data.value);
}
public void SwitchEnum(TypeOfThing switchedSituation)
{
((ConfigField)Tolerance).hidden = true;
((ConfigField)color).hidden = true;
((ConfigField)keyField).hidden = true;
((ConfigField)stringParam).hidden = true;
((ConfigField)numberField).hidden = true;
((ConfigField)WhileSituation).hidden = true;
((ConfigField)delayField).hidden = true;
situationEnum situationEnum = situationSettings.Find((situationEnum x) => x.situation == switchedSituation);
if (situationEnum == null)
{
return;
}
using (List<param>.Enumerator enumerator = situationEnum.requiredParams.GetEnumerator())
{
while (enumerator.MoveNext())
{
switch (enumerator.Current)
{
case param.Color:
((ConfigField)Tolerance).hidden = false;
((ConfigField)color).hidden = false;
break;
case param.KeyCode:
((ConfigField)keyField).hidden = false;
break;
case param.AString:
((ConfigField)stringParam).hidden = false;
break;
case param.Number:
((ConfigField)numberField).hidden = false;
break;
}
}
}
if (situationEnum.canDoWhile)
{
((ConfigField)WhileSituation).hidden = false;
((ConfigField)delayField).hidden = false;
}
if (situationEnum.justDelayNoWhile)
{
((ConfigField)delayField).hidden = false;
}
}
public void ResetID(int id)
{
ID = id;
header.text = "Challenge setting " + ID;
}
public void SwitchHappen(whatShouldHappen switchedSituation)
{
whatShouldHappenEnum whatShouldHappenEnum = whatShouldHappenSettings.Find((whatShouldHappenEnum x) => x.shouldHappen == switchedSituation);
bool canDoMath = whatShouldHappenEnum.canDoMath;
((ConfigField)weDoALittleMath).hidden = !canDoMath;
((ConfigField)amountComplexMath).hidden = true;
((ConfigField)explosionList).hidden = true;
if (weDoALittleMath.value == math.Complex && canDoMath)
{
((ConfigField)amountComplexMath).hidden = false;
}
switch (switchedSituation)
{
case whatShouldHappen.Damage:
case whatShouldHappen.Speed:
case whatShouldHappen.JumpPower:
case whatShouldHappen.KillEnemy:
case whatShouldHappen.DupeEnemy:
case whatShouldHappen.BuffEnemy:
case whatShouldHappen.RemoveGameObject:
case whatShouldHappen.SpawnAddressable:
((ConfigField)amount).hidden = false;
break;
default:
((ConfigField)amount).hidden = !canDoMath;
break;
}
((ConfigField)saveValue).hidden = !whatShouldHappenEnum.canSaveThroughLevels;
if (switchedSituation == whatShouldHappen.SpawnExplosion)
{
((ConfigField)explosionList).hidden = false;
}
((ConfigField)distanceField).hidden = true;
whatShouldHappen whatShouldHappen2 = switchedSituation;
whatShouldHappen whatShouldHappen3 = whatShouldHappen2;
if ((uint)(whatShouldHappen3 - 4) <= 2u || whatShouldHappen3 == whatShouldHappen.RemoveGameObject)
{
((ConfigField)distanceField).hidden = false;
}
((ConfigField)addressablePath).hidden = true;
if (switchedSituation == whatShouldHappen.SpawnAddressable)
{
((ConfigField)addressablePath).hidden = false;
}
((ConfigField)spawnLocation).hidden = true;
if (switchedSituation == whatShouldHappen.SpawnExplosion || switchedSituation == whatShouldHappen.SpawnAddressable)
{
((ConfigField)spawnLocation).hidden = false;
}
}
}
}
namespace ULTRACHALLENGE.Utils
{
public class Handlers
{
private static readonly List<string> validLevels = new List<string>
{
"Level 0-1", "Level 0-2", "Level 0-3", "Level 0-4", "Level 0-5", "Level 1-1", "Level 1-2", "Level 1-3", "Level 1-4", "Level 2-1",
"Level 2-2", "Level 2-3", "Level 2-4", "Level 3-1", "Level 3-2", "Level 4-1", "Level 4-2", "Level 4-3", "Level 4-4", "Level 5-1",
"Level 5-2", "Level 5-3", "Level 5-4", "Level 6-1", "Level 6-2", "Level 7-1", "Level 7-2", "Level 7-3", "Level 7-4", "Level 0-S",
"Level 1-S", "Level 2-S", "Level 4-S", "Level 5-S", "Level 7-S", "Level P-1", "Level P-2"
};
public static bool canUseThing()
{
if ((Object)(object)MonoSingleton<NewMovement>.Instance == (Object)null)
{
return false;
}
if (!((Behaviour)MonoSingleton<NewMovement>.Instance).enabled)
{
return false;
}
string[] source = new string[6] { "Intro", "Bootstrap", "Main Menu", "Level 2-S", "Intermission1", "Intermission2" };
return !source.Contains(SceneHelper.CurrentScene);
}
public static float GetValueForHandling(float initialAmount, ChallengeSetting setting)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
float num = initialAmount;
Scene activeScene = SceneManager.GetActiveScene();
int buildIndex = ((Scene)(ref activeScene)).buildIndex;
switch (setting.weDoALittleMath.value)
{
case math.Set:
num = setting.amount.value;
break;
case math.Increase:
num += (float)setting.amount.value;
break;
case math.Decrease:
num -= (float)setting.amount.value;
break;
case math.Divide:
num /= (float)setting.amount.value;
break;
case math.Multiply:
num *= (float)setting.amount.value;
break;
case math.Complex:
num = MathParser.HandleComplexMath(setting.amountComplexMath.value, num, buildIndex);
break;
}
return num;
}
public static void HandleSpeed(ChallengeSetting setting)
{
MonoSingleton<NewMovement>.Instance.walkSpeed = GetValueForHandling(MonoSingleton<NewMovement>.Instance.walkSpeed, setting);
if (setting.saveValue.value)
{
setting.savedValue = MonoSingleton<NewMovement>.Instance.walkSpeed;
setting.ValueAlreadySet = true;
}
}
public static void HandleJump(ChallengeSetting setting)
{
MonoSingleton<NewMovement>.Instance.jumpPower = GetValueForHandling(MonoSingleton<NewMovement>.Instance.jumpPower, setting);
if (setting.saveValue.value)
{
setting.savedValue = MonoSingleton<NewMovement>.Instance.jumpPower;
setting.ValueAlreadySet = true;
}
}
public static float GetMaxValueOfLink(Linkable linkable)
{
return linkable switch
{
Linkable.Health => 100f,
Linkable.Speed => 750f,
Linkable.JumpHeight => 90f,
Linkable.Pixelization => 720f,
Linkable.FOV => 165f,
Linkable.VertexWarping => 400f,
Linkable.Gamma => 2f,
Linkable.Velocity => 16.5f * (MonoSingleton<NewMovement>.Instance.walkSpeed / 750f),
Linkable.FrameRate => 288f,
Linkable.Gravity => -40f,
Linkable.Time => 1f,
Linkable.Stamina => 300f,
_ => 0f,
};
}
public static float getValue(Linkable link)
{
//IL_00af: Unknown result type (might be due to invalid IL or missing references)
//IL_00b4: 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)
switch (link)
{
case Linkable.Health:
return MonoSingleton<NewMovement>.Instance.hp;
case Linkable.Speed:
return MonoSingleton<NewMovement>.Instance.walkSpeed;
case Linkable.JumpHeight:
return MonoSingleton<NewMovement>.Instance.jumpPower;
case Linkable.Pixelization:
return Shader.GetGlobalFloat("_ResY");
case Linkable.FOV:
return Camera.main.fieldOfView;
case Linkable.VertexWarping:
return Shader.GetGlobalFloat("_VertexWarping");
case Linkable.Gamma:
return Shader.GetGlobalFloat("_Gamma");
case Linkable.Velocity:
{
Vector3 playerVelocity = MonoSingleton<PlayerTracker>.Instance.GetPlayerVelocity(true);
return ((Vector3)(ref playerVelocity)).magnitude;
}
case Linkable.FrameRate:
return 1f / Time.unscaledDeltaTime;
case Linkable.Gravity:
return Physics.gravity.y;
case Linkable.Time:
return Time.timeScale;
case Linkable.Stamina:
return MonoSingleton<NewMovement>.Instance.boostCharge;
default:
return 0f;
}
}
public static float GetValueCalculated(float value, float maxValue, float otherMaxValue, bool reverse)
{
float num = value / maxValue * otherMaxValue;
return reverse ? (otherMaxValue - num) : num;
}
public static void setLinkables(Linkable linkable, Linkable link2, bool reverse, float multiplier, float offset)
{
//IL_0155: 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_0198: Unknown result type (might be due to invalid IL or missing references)
if (!canUseThing())
{
return;
}
float maxValueOfLink = GetMaxValueOfLink(linkable);
float maxValueOfLink2 = GetMaxValueOfLink(link2);
float value = getValue(linkable);
float num = GetValueCalculated(value, maxValueOfLink, maxValueOfLink2, reverse) * multiplier + offset;
switch (link2)
{
case Linkable.Health:
MonoSingleton<NewMovement>.Instance.hp = (int)num;
break;
case Linkable.Speed:
MonoSingleton<NewMovement>.Instance.walkSpeed = num;
break;
case Linkable.JumpHeight:
MonoSingleton<NewMovement>.Instance.jumpPower = num;
break;
case Linkable.Pixelization:
{
float num2 = num;
Shader.SetGlobalFloat("_ResY", num2);
PostProcessV2_Handler instance = MonoSingleton<PostProcessV2_Handler>.Instance;
if (Object.op_Implicit((Object)(object)instance))
{
instance.downscaleResolution = num2;
}
DownscaleChangeSprite[] array = Object.FindObjectsOfType<DownscaleChangeSprite>();
for (int i = 0; i < array.Length; i++)
{
array[i].CheckScale();
}
break;
}
case Linkable.FOV:
Camera.main.fieldOfView = num;
break;
case Linkable.VertexWarping:
Shader.SetGlobalFloat("_VertexWarping", num);
break;
case Linkable.Gamma:
Shader.SetGlobalFloat("_Gamma", num);
break;
case Linkable.Velocity:
MonoSingleton<NewMovement>.Instance.rb.velocity = ((Component)MonoSingleton<CameraController>.Instance).transform.forward * num;
break;
case Linkable.FrameRate:
if (QualitySettings.vSyncCount == 1)
{
QualitySettings.vSyncCount = 0;
}
Application.targetFrameRate = (int)Math.Ceiling(num);
break;
case Linkable.Gravity:
Physics.gravity = new Vector3(0f, num, 0f);
break;
case Linkable.Time:
Time.timeScale = num;
break;
case Linkable.Stamina:
MonoSingleton<NewMovement>.Instance.boostCharge = num;
break;
case Linkable.Sensitivity:
break;
}
}
public static void HandleThing(ChallengeSetting setting, Transform triggerLocation)
{
//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
//IL_0097: 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_0180: Unknown result type (might be due to invalid IL or missing references)
//IL_0185: Unknown result type (might be due to invalid IL or missing references)
//IL_03d2: Unknown result type (might be due to invalid IL or missing references)
//IL_03e7: Unknown result type (might be due to invalid IL or missing references)
//IL_040c: Unknown result type (might be due to invalid IL or missing references)
//IL_0411: Unknown result type (might be due to invalid IL or missing references)
if (!canUseThing() || setting.challengeType.value != 0)
{
return;
}
if (setting.ChanceField.value < 100f)
{
float num = Random.Range(0, 100);
if (num > setting.ChanceField.value)
{
return;
}
}
Vector3 locationSpawn = ((setting.spawnLocation.value == spawnLocation.player) ? ((Component)MonoSingleton<NewMovement>.Instance).transform.position : triggerLocation.position);
switch (setting.whatShouldItDo.value)
{
case whatShouldHappen.Damage:
MonoSingleton<NewMovement>.Instance.GetHurt(setting.amount.value, false, 1f, false, false, 0.35f, false);
break;
case whatShouldHappen.Speed:
HandleSpeed(setting);
break;
case whatShouldHappen.JumpPower:
HandleJump(setting);
break;
case whatShouldHappen.SpawnExplosion:
Object.Instantiate<GameObject>(setting.selectedExplosion, locationSpawn, Quaternion.identity);
break;
case whatShouldHappen.KillEnemy:
{
for (int m = 0; m < setting.amount.value; m++)
{
KillEnemy(setting);
}
break;
}
case whatShouldHappen.BuffEnemy:
{
for (int k = 0; k < setting.amount.value; k++)
{
BuffEnemy(setting);
}
break;
}
case whatShouldHappen.DupeEnemy:
{
for (int i = 0; i < setting.amount.value; i++)
{
DupeEnemy(setting);
}
break;
}
case whatShouldHappen.Pixelization:
{
float valueForHandling = GetValueForHandling(Shader.GetGlobalFloat("_ResY"), setting);
Shader.SetGlobalFloat("_ResY", valueForHandling);
PostProcessV2_Handler instance = MonoSingleton<PostProcessV2_Handler>.Instance;
if (Object.op_Implicit((Object)(object)instance))
{
instance.downscaleResolution = valueForHandling;
}
DownscaleChangeSprite[] array = Object.FindObjectsOfType<DownscaleChangeSprite>();
for (int l = 0; l < array.Length; l++)
{
array[l].CheckScale();
}
break;
}
case whatShouldHappen.FOV:
Camera.main.fieldOfView = GetValueForHandling(Camera.main.fieldOfView, setting);
break;
case whatShouldHappen.VertexWarping:
Shader.SetGlobalFloat("_VertexWarping", GetValueForHandling(Shader.GetGlobalFloat("_VertexWarping"), setting));
break;
case whatShouldHappen.Gamma:
Shader.SetGlobalFloat("_Gamma", GetValueForHandling(Shader.GetGlobalFloat("_Gamma"), setting));
break;
case whatShouldHappen.ChangeToRandomLevel:
SelectRandomLevel();
break;
case whatShouldHappen.ChangeLevel:
SceneHelper.LoadScene(GetMissionName.GetSceneName(setting.amount.value), false);
break;
case whatShouldHappen.RestartLevel:
MonoSingleton<OptionsManager>.Instance.RestartMission();
break;
case whatShouldHappen.Framerate:
if (QualitySettings.vSyncCount == 1)
{
QualitySettings.vSyncCount = 0;
}
Application.targetFrameRate = (int)Math.Ceiling(GetValueForHandling(Application.targetFrameRate, setting));
break;
case whatShouldHappen.RemoveGameObject:
{
for (int j = 0; j < setting.amount.value; j++)
{
RemoveObject(setting);
}
break;
}
case whatShouldHappen.Gravity:
Physics.gravity = new Vector3(0f, GetValueForHandling(Physics.gravity.y, setting));
break;
case whatShouldHappen.Quit:
Application.Quit();
break;
case whatShouldHappen.SpawnAddressable:
{
AsyncOperationHandle<GameObject> val = Addressables.LoadAssetAsync<GameObject>((object)setting.addressablePath.value);
val.Completed += delegate(AsyncOperationHandle<GameObject> operation)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Invalid comparison between Unknown and I4
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
if ((int)operation.Status == 1)
{
for (int n = 0; n < setting.amount.value; n++)
{
Object.Instantiate<GameObject>(operation.Result, locationSpawn, Quaternion.identity);
}
}
};
break;
}
case whatShouldHappen.RemoveTriggerer:
if ((Object)(object)triggerLocation != (Object)(object)((Component)MonoSingleton<NewMovement>.Instance).transform)
{
Object.Destroy((Object)(object)((Component)triggerLocation).gameObject);
}
break;
}
}
private static void RemoveObject(ChallengeSetting setting)
{
GameObject gameObject = ((Component)MonoSingleton<NewMovement>.Instance).gameObject;
List<GameObject> list = (from x in Object.FindObjectsOfType<GameObject>()
orderby Vector3.Distance(x.transform.position, ((Component)MonoSingleton<NewMovement>.Instance).transform.position)
select x).ToList();
GameObject val = null;
if (list.Count != 0)
{
HashSet<GameObject> objectsToRemove = new HashSet<GameObject>();
if ((Object)(object)gameObject != (Object)null)
{
GetAllChildren(gameObject.transform, objectsToRemove);
objectsToRemove.Add(gameObject);
}
list.RemoveAll((GameObject obj) => objectsToRemove.Contains(obj.gameObject));
switch (setting.distanceField.value)
{
case distance.Closest:
val = list[0];
break;
case distance.Furthest:
val = list.Last();
break;
case distance.Inbetween:
val = list[Mathf.FloorToInt((float)(list.Count / 2))];
break;
case distance.Random:
val = list[Random.Range(0, list.Count)];
break;
}
Object.Destroy((Object)(object)val);
}
}
private static void GetAllChildren(Transform parent, HashSet<GameObject> list)
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Expected O, but got Unknown
foreach (Transform item in parent)
{
Transform val = item;
list.Add(((Component)val).gameObject);
GetAllChildren(val, list);
}
}
private static void KillEnemy(ChallengeSetting setting)
{
EnemyIdentifier enemy = GetEnemy(setting);
if ((Object)(object)enemy != (Object)null)
{
enemy.InstaKill();
}
}
private static void DupeEnemy(ChallengeSetting setting)
{
//IL_001f: 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)
EnemyIdentifier enemy = GetEnemy(setting);
if ((Object)(object)enemy != (Object)null)
{
Object.Instantiate<GameObject>(((Component)enemy).gameObject, ((Component)enemy).transform.position, ((Component)enemy).transform.rotation);
}
}
private static void BuffEnemy(ChallengeSetting setting)
{
EnemyIdentifier enemy = GetEnemy(setting);
if ((Object)(object)enemy != (Object)null)
{
enemy.BuffAll();
}
}
private static EnemyIdentifier GetEnemy(ChallengeSetting setting)
{
List<EnemyIdentifier> list = (from x in MonoSingleton<EnemyTracker>.Instance.GetCurrentEnemies()
orderby Vector3.Distance(((Component)x).transform.position, ((Component)MonoSingleton<NewMovement>.Instance).transform.position)
select x).ToList();
EnemyIdentifier result = null;
if (list.Count == 0)
{
return null;
}
switch (setting.distanceField.value)
{
case distance.Closest:
result = list[0];
break;
case distance.Furthest:
result = list.Last();
break;
case distance.Inbetween:
result = list[Mathf.FloorToInt((float)(list.Count / 2))];
break;
case distance.Random:
result = list[Random.Range(0, list.Count)];
break;
}
return result;
}
public static void SelectRandomLevel()
{
SceneHelper.LoadScene(validLevels[Random.Range(0, validLevels.Count)], false);
}
public static bool IsBloodNearby(float radius = 5f)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: 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)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: 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_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
//IL_0076: 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_0079: Unknown result type (might be due to invalid IL or missing references)
BloodsplatterManager instance = MonoSingleton<BloodsplatterManager>.Instance;
if ((Object)(object)instance == (Object)null)
{
return false;
}
Vector3 position = ((Component)MonoSingleton<NewMovement>.Instance).transform.position;
float3 val = default(float3);
((float3)(ref val))..ctor(position.x, position.y, position.z);
for (int i = 0; i < instance.props.Length; i++)
{
InstanceProperties val2 = instance.props[i];
if (!((float3)(ref val2.pos)).Equals(default(float3)))
{
float num = math.distance(val, val2.pos);
if (num <= radius)
{
return true;
}
}
}
return false;
}
}
}
namespace ULTRACHALLENGE.Patches
{
[HarmonyPatch(typeof(NewMovement))]
internal class OnColorTouch
{
[HarmonyPrefix]
[HarmonyPatch("Start")]
public static void Prefix(NewMovement __instance)
{
foreach (ChallengeSetting challengeSetting in ULTRACHALLENGEPlugin.ChallengeSettings)
{
switch (challengeSetting.situation.value)
{
case TypeOfThing.OnTouchColor:
((Component)__instance).gameObject.AddComponent<DetectColorTouching>().setting = challengeSetting;
break;
case TypeOfThing.OnTouchGameObject:
((Component)__instance).gameObject.AddComponent<DetectObjectTouching>().setting = challengeSetting;
break;
}
}
}
[HarmonyPrefix]
[HarmonyPatch("Update")]
public static void OnDashing(NewMovement __instance)
{
if (!__instance.inman.InputSource.Dodge.WasPerformedThisFrame || (Object.op_Implicit((Object)(object)__instance.groundProperties) && !__instance.groundProperties.canDash) || __instance.modNoDashSlide || !(__instance.boostCharge >= 100f))
{
return;
}
foreach (ChallengeSetting challengeSetting in ULTRACHALLENGEPlugin.ChallengeSettings)
{
if (challengeSetting.situation.value == TypeOfThing.OnDash)
{
Handlers.HandleThing(challengeSetting, ((Component)__instance).transform);
}
}
}
[HarmonyPrefix]
[HarmonyPatch("Jump")]
public static void OnJump(NewMovement __instance)
{
foreach (ChallengeSetting challengeSetting in ULTRACHALLENGEPlugin.ChallengeSettings)
{
if (challengeSetting.situation.value == TypeOfThing.OnJump)
{
Handlers.HandleThing(challengeSetting, ((Component)__instance).transform);
}
}
}
[HarmonyPrefix]
[HarmonyPatch("StartSlide")]
public static void OnSlide(NewMovement __instance)
{
foreach (ChallengeSetting challengeSetting in ULTRACHALLENGEPlugin.ChallengeSettings)
{
if (challengeSetting.situation.value == TypeOfThing.OnSlide)
{
Handlers.HandleThing(challengeSetting, ((Component)__instance).transform);
}
}
}
[HarmonyPrefix]
[HarmonyPatch("GetHurt")]
public static void OnTakeDamage(NewMovement __instance)
{
Debug.Log((object)"Im hurting!!!");
foreach (ChallengeSetting challengeSetting in ULTRACHALLENGEPlugin.ChallengeSettings)
{
if (challengeSetting.situation.value == TypeOfThing.OnTakeDamage)
{
Handlers.HandleThing(challengeSetting, ((Component)__instance).transform);
}
}
}
[HarmonyPrefix]
[HarmonyPatch("GetHealth")]
public static void Onheal(NewMovement __instance)
{
Debug.Log((object)"Im hurting!!!");
foreach (ChallengeSetting challengeSetting in ULTRACHALLENGEPlugin.ChallengeSettings)
{
if (challengeSetting.situation.value == TypeOfThing.OnHeal)
{
Handlers.HandleThing(challengeSetting, ((Component)__instance).transform);
}
}
}
[HarmonyPrefix]
[HarmonyPatch("Respawn")]
public static void OnRespawn(NewMovement __instance)
{
Debug.Log((object)"Im hurting!!!");
foreach (ChallengeSetting challengeSetting in ULTRACHALLENGEPlugin.ChallengeSettings)
{
if (challengeSetting.situation.value == TypeOfThing.OnDeath)
{
Handlers.HandleThing(challengeSetting, ((Component)__instance).transform);
}
}
}
}
public class DetectColorTouching : MonoBehaviour
{
public Color targetColor = Color.green;
public float colorTolerance = 0.5f;
public ChallengeSetting setting;
private float lastTriggerTime = -999f;
private void OnCollisionEnter(Collision collision)
{
//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_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: 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)
Renderer component = ((Component)collision.collider).GetComponent<Renderer>();
if ((Object)(object)component != (Object)null && (Object)(object)component.material.mainTexture != (Object)null)
{
Color averageColor = GetAverageColor(component.material.mainTexture);
if (IsColorMatch(averageColor * component.material.color, setting.color.value, setting.Tolerance.value))
{
Handlers.HandleThing(setting, ((Component)this).transform);
}
}
}
private void OnCollisionStay(Collision collision)
{
//IL_0069: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: 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_008e: Unknown result type (might be due to invalid IL or missing references)
if (!setting.WhileSituation.value || !CanTrigger())
{
return;
}
Renderer component = ((Component)collision.collider).GetComponent<Renderer>();
if ((Object)(object)component != (Object)null && (Object)(object)component.material.mainTexture != (Object)null)
{
Color averageColor = GetAverageColor(component.material.mainTexture);
if (IsColorMatch(averageColor * component.material.color, setting.color.value, setting.Tolerance.value))
{
Handlers.HandleThing(setting, ((Component)this).transform);
UpdateLastTriggerTime();
}
}
}
private bool CanTrigger()
{
return Time.time >= lastTriggerTime + setting.delayField.value;
}
private void UpdateLastTriggerTime()
{
lastTriggerTime = Time.time;
}
private Color GetAverageColor(Texture texture)
{
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Expected O, but got Unknown
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
//IL_0086: Unknown result type (might be due to invalid IL or missing references)
//IL_0095: 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_009c: Unknown result type (might be due to invalid IL or missing references)
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
//IL_00bb: 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_00c4: Unknown result type (might be due to invalid IL or missing references)
RenderTexture temporary = RenderTexture.GetTemporary(texture.width, texture.height, 0, (RenderTextureFormat)7, (RenderTextureReadWrite)1);
Graphics.Blit(texture, temporary);
RenderTexture active = RenderTexture.active;
RenderTexture.active = temporary;
Texture2D val = new Texture2D(texture.width, texture.height, (TextureFormat)3, false);
val.ReadPixels(new Rect(0f, 0f, (float)texture.width, (float)texture.height), 0, 0);
val.Apply();
RenderTexture.active = active;
RenderTexture.ReleaseTemporary(temporary);
Color[] pixels = val.GetPixels();
Color val2 = Color.black;
Color[] array = pixels;
foreach (Color val3 in array)
{
val2 += val3;
}
return val2 / (float)pixels.Length;
}
private bool IsColorMatch(Color a, Color b, float tolerance)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: 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)
return Mathf.Abs(a.r - b.r) < tolerance && Mathf.Abs(a.g - b.g) < tolerance && Mathf.Abs(a.b - b.b) < tolerance;
}
}
[HarmonyPatch(typeof(GunControl))]
internal class OnWeaponSwapTrigger
{
[HarmonyPatch("SwitchVariant")]
[HarmonyPatch("SwitchWeapon", new Type[]
{
typeof(int),
typeof(List<GameObject>),
typeof(bool),
typeof(bool),
typeof(bool),
typeof(bool)
})]
public static void Postfix(GunControl __instance)
{
foreach (ChallengeSetting challengeSetting in ULTRACHALLENGEPlugin.ChallengeSettings)
{
if (challengeSetting.situation.value == TypeOfThing.OnWeaponSwitch)
{
Handlers.HandleThing(challengeSetting, ((Component)__instance).transform);
}
}
}
}
[HarmonyPatch(typeof(EnemyIdentifier))]
internal class OnEnemyDeath
{
[HarmonyPatch("Death", new Type[] { typeof(bool) })]
[HarmonyPrefix]
public static void DIe(EnemyIdentifier __instance)
{
if (__instance.dead)
{
return;
}
foreach (ChallengeSetting challengeSetting in ULTRACHALLENGEPlugin.ChallengeSettings)
{
if (challengeSetting.situation.value == TypeOfThing.OnEnemyKill)
{
Handlers.HandleThing(challengeSetting, ((Component)__instance).transform);
}
}
}
}
[HarmonyPatch("Shoot")]
internal class OnShoot
{
[HarmonyPatch(typeof(Revolver))]
[HarmonyPostfix]
public static void Pew(Revolver __instance)
{
foreach (ChallengeSetting challengeSetting in ULTRACHALLENGEPlugin.ChallengeSettings)
{
if (challengeSetting.situation.value == TypeOfThing.Shoot)
{
Handlers.HandleThing(challengeSetting, ((Component)__instance).transform);
}
}
}
[HarmonyPatch(typeof(RocketLauncher))]
[HarmonyPostfix]
public static void PewRoc(RocketLauncher __instance)
{
foreach (ChallengeSetting challengeSetting in ULTRACHALLENGEPlugin.ChallengeSettings)
{
if (challengeSetting.situation.value == TypeOfThing.Shoot)
{
Handlers.HandleThing(challengeSetting, ((Component)__instance).transform);
}
}
}
[HarmonyPatch(typeof(Shotgun))]
[HarmonyPostfix]
public static void PewSHo(Shotgun __instance)
{
foreach (ChallengeSetting challengeSetting in ULTRACHALLENGEPlugin.ChallengeSettings)
{
if (challengeSetting.situation.value == TypeOfThing.Shoot)
{
Handlers.HandleThing(challengeSetting, ((Component)__instance).transform);
}
}
}
[HarmonyPatch(typeof(Railcannon))]
[HarmonyPostfix]
public static void PewRai(Railcannon __instance)
{
foreach (ChallengeSetting challengeSetting in ULTRACHALLENGEPlugin.ChallengeSettings)
{
if (challengeSetting.situation.value == TypeOfThing.Shoot)
{
Handlers.HandleThing(challengeSetting, ((Component)__instance).transform);
}
}
}
[HarmonyPatch(typeof(Nailgun))]
[HarmonyPostfix]
public static void PewNai(Nailgun __instance)
{
foreach (ChallengeSetting challengeSetting in ULTRACHALLENGEPlugin.ChallengeSettings)
{
if (challengeSetting.situation.value == TypeOfThing.Shoot)
{
Handlers.HandleThing(challengeSetting, ((Component)__instance).transform);
}
}
}
}
[HarmonyPatch(typeof(ShotgunHammer), "Impact")]
internal class OnImpact
{
[HarmonyPostfix]
public static void pow(ShotgunHammer __instance)
{
foreach (ChallengeSetting challengeSetting in ULTRACHALLENGEPlugin.ChallengeSettings)
{
if (challengeSetting.situation.value == TypeOfThing.Shoot)
{
Handlers.HandleThing(challengeSetting, ((Component)__instance).transform);
}
}
}
}
[HarmonyPatch(typeof(Punch), "PunchStart")]
internal class OnPunch
{
[HarmonyPostfix]
public static void FALCONPUNCH(Punch __instance)
{
foreach (ChallengeSetting challengeSetting in ULTRACHALLENGEPlugin.ChallengeSettings)
{
if (challengeSetting.situation.value == TypeOfThing.Punch)
{
Handlers.HandleThing(challengeSetting, ((Component)__instance).transform);
}
}
}
}
[HarmonyPatch(typeof(ChessManager), "UpdateGame")]
internal class PieceMove
{
[HarmonyPostfix]
public static void MOVE(ChessManager __instance, MoveData move)
{
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
foreach (ChallengeSetting challengeSetting in ULTRACHALLENGEPlugin.ChallengeSettings)
{
if (challengeSetting.situation.value == TypeOfThing.OnPieceMove)
{
Handlers.HandleThing(challengeSetting, ((Component)__instance.allPieces[move.PieceToMove]).transform);
}
}
}
}
[HarmonyPatch(typeof(ChessPiece), "Captured")]
internal class OnPieceCapture
{
[HarmonyPostfix]
public static void CAPTURE(ChessPiece __instance)
{
foreach (ChallengeSetting challengeSetting in ULTRACHALLENGEPlugin.ChallengeSettings)
{
if (challengeSetting.situation.value == TypeOfThing.OnPieceCapture)
{
Handlers.HandleThing(challengeSetting, ((Component)__instance).transform);
}
}
}
}
[HarmonyPatch(typeof(EnemyIdentifier), "Start")]
internal class OnEnemySpawn
{
[HarmonyPostfix]
public static void SPAWN(EnemyIdentifier __instance)
{
foreach (ChallengeSetting challengeSetting in ULTRACHALLENGEPlugin.ChallengeSettings)
{
if (challengeSetting.situation.value == TypeOfThing.OnEnemySpawn)
{
Handlers.HandleThing(challengeSetting, ((Component)__instance).transform);
}
}
}
}
[HarmonyPatch]
internal class OnParry
{
[HarmonyPatch(typeof(NewMovement), "Parry")]
[HarmonyPostfix]
public static void Postfix(NewMovement __instance)
{
Debug.Log((object)"I paarried");
foreach (ChallengeSetting challengeSetting in ULTRACHALLENGEPlugin.ChallengeSettings)
{
if (challengeSetting.situation.value == TypeOfThing.OnParry)
{
Debug.Log((object)"HANDLE IT");
Handlers.HandleThing(challengeSetting, ((Component)__instance).transform);
}
}
}
[HarmonyPatch(typeof(Punch), "Parry")]
[HarmonyPostfix]
public static void LePunchParry(Punch __instance)
{
Debug.Log((object)"I paarried");
foreach (ChallengeSetting challengeSetting in ULTRACHALLENGEPlugin.ChallengeSettings)
{
if (challengeSetting.situation.value == TypeOfThing.OnParry)
{
Debug.Log((object)"HANDLE IT");
Handlers.HandleThing(challengeSetting, ((Component)__instance).transform);
}
}
}
[HarmonyPatch(typeof(Punch), "TryParryProjectile")]
[HarmonyPostfix]
public static void ParryPucnhProj(Punch __instance)
{
Debug.Log((object)"I paarried");
foreach (ChallengeSetting challengeSetting in ULTRACHALLENGEPlugin.ChallengeSettings)
{
if (challengeSetting.situation.value == TypeOfThing.OnParry)
{
Debug.Log((object)"HANDLE IT");
Handlers.HandleThing(challengeSetting, ((Component)__instance).transform);
}
}
}
}
public class DetectObjectTouching : MonoBehaviour
{
public ChallengeSetting setting;
private float lastTriggerTime = -999f;
private void OnCollisionEnter(Collision collision)
{
if (MatchesPattern(((Object)collision.gameObject).name.ToLower(), setting.stringParam.value))
{
Handlers.HandleThing(setting, ((Component)this).transform);
}
}
private void OnCollisionStay(Collision collision)
{
if (setting.WhileSituation.value && CanTrigger() && MatchesPattern(((Object)collision.gameObject).name.ToLower(), setting.stringParam.value))
{
Handlers.HandleThing(setting, ((Component)this).transform);
UpdateLastTriggerTime();
}
}
private bool CanTrigger()
{
return Time.time >= lastTriggerTime + setting.delayField.value;
}
private void UpdateLastTriggerTime()
{
lastTriggerTime = Time.time;
}
private bool MatchesPattern(string name, string pattern)
{
string[] array = pattern.Split(new char[1] { '^' });
if (array.Length == 0)
{
return true;
}
if (array[0].StartsWith("%"))
{
if (!name.Contains(array[0].Trim(new char[1] { '%' })))
{
return false;
}
}
else if (!name.StartsWith(array[0]))
{
return false;
}
for (int i = 1; i < array.Length - 1; i++)
{
if (!name.Contains(array[i]))
{
return false;
}
}
string text = array[^1];
if (text.EndsWith("%"))
{
if (!name.Contains(text.Trim(new char[1] { '%' })))
{
return false;
}
}
else if (!name.EndsWith(text))
{
return false;
}
return true;
}
}
[HarmonyPatch(typeof(GameStateManager))]
[HarmonyPatch(/*Could not decode attribute arguments.*/)]
public class dontsubmit
{
public static bool Prefix(ref bool __result)
{
if (ULTRACHALLENGEPlugin.ChallengeSettings.Count == 0)
{
return true;
}
__result = false;
return false;
}
}
}
