using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using AbilityApi.Internal;
using BepInEx;
using BoplFixedMath;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("AbilityApi")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("My first plugin")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+a84e6690eadc270b4f3fa750381255da3b32d6db")]
[assembly: AssemblyProduct("AbilityApi")]
[assembly: AssemblyTitle("AbilityApi")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace MiniJSON
{
public static class Json
{
private sealed class Parser : IDisposable
{
private enum TOKEN
{
NONE,
CURLY_OPEN,
CURLY_CLOSE,
SQUARED_OPEN,
SQUARED_CLOSE,
COLON,
COMMA,
STRING,
NUMBER,
TRUE,
FALSE,
NULL
}
private const string WORD_BREAK = "{}[],:\"";
private const string HEX_DIGIT = "0123456789ABCDEFabcdef";
private StringReader json;
private char PeekChar => Convert.ToChar(json.Peek());
private char NextChar => Convert.ToChar(json.Read());
private string NextWord
{
get
{
StringBuilder stringBuilder = new StringBuilder();
while (!IsWordBreak(PeekChar))
{
stringBuilder.Append(NextChar);
if (json.Peek() == -1)
{
break;
}
}
return stringBuilder.ToString();
}
}
private TOKEN NextToken
{
get
{
EatWhitespace();
if (json.Peek() == -1)
{
return TOKEN.NONE;
}
switch (PeekChar)
{
case '{':
return TOKEN.CURLY_OPEN;
case '}':
json.Read();
return TOKEN.CURLY_CLOSE;
case '[':
return TOKEN.SQUARED_OPEN;
case ']':
json.Read();
return TOKEN.SQUARED_CLOSE;
case ',':
json.Read();
return TOKEN.COMMA;
case '"':
return TOKEN.STRING;
case ':':
return TOKEN.COLON;
case '-':
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
return TOKEN.NUMBER;
default:
return NextWord switch
{
"false" => TOKEN.FALSE,
"true" => TOKEN.TRUE,
"null" => TOKEN.NULL,
_ => TOKEN.NONE,
};
}
}
}
public static bool IsWordBreak(char c)
{
return char.IsWhiteSpace(c) || "{}[],:\"".IndexOf(c) != -1;
}
public static bool IsHexDigit(char c)
{
return "0123456789ABCDEFabcdef".IndexOf(c) != -1;
}
private Parser(string jsonString)
{
json = new StringReader(jsonString);
}
public static object Parse(string jsonString)
{
using Parser parser = new Parser(jsonString);
return parser.ParseValue();
}
public void Dispose()
{
json.Dispose();
json = null;
}
private Dictionary<string, object> ParseObject()
{
Dictionary<string, object> dictionary = new Dictionary<string, object>();
json.Read();
while (true)
{
string text;
object obj;
switch (NextToken)
{
case TOKEN.NONE:
return null;
case TOKEN.CURLY_CLOSE:
return dictionary;
case TOKEN.STRING:
{
text = ParseString();
if (text == null)
{
return null;
}
if (NextToken != TOKEN.COLON)
{
return null;
}
json.Read();
TOKEN nextToken = NextToken;
obj = ParseByToken(nextToken);
if (obj == null && nextToken != TOKEN.NULL)
{
return null;
}
goto IL_00ba;
}
default:
return null;
case TOKEN.COMMA:
break;
}
continue;
IL_00ba:
dictionary[text] = obj;
}
}
private List<object> ParseArray()
{
List<object> list = new List<object>();
json.Read();
bool flag = true;
while (flag)
{
TOKEN nextToken = NextToken;
switch (nextToken)
{
case TOKEN.NONE:
return null;
case TOKEN.SQUARED_CLOSE:
flag = false;
continue;
case TOKEN.COMMA:
continue;
}
object obj = ParseByToken(nextToken);
if (obj == null && nextToken != TOKEN.NULL)
{
return null;
}
list.Add(obj);
}
return list;
}
private object ParseValue()
{
TOKEN nextToken = NextToken;
return ParseByToken(nextToken);
}
private object ParseByToken(TOKEN token)
{
return token switch
{
TOKEN.STRING => ParseString(),
TOKEN.NUMBER => ParseNumber(),
TOKEN.CURLY_OPEN => ParseObject(),
TOKEN.SQUARED_OPEN => ParseArray(),
TOKEN.TRUE => true,
TOKEN.FALSE => false,
TOKEN.NULL => null,
_ => null,
};
}
private string ParseString()
{
StringBuilder stringBuilder = new StringBuilder();
json.Read();
bool flag = true;
while (flag)
{
if (json.Peek() == -1)
{
flag = false;
break;
}
char nextChar = NextChar;
switch (nextChar)
{
case '"':
flag = false;
break;
case '\\':
if (json.Peek() == -1)
{
flag = false;
break;
}
nextChar = NextChar;
switch (nextChar)
{
case '"':
case '/':
case '\\':
stringBuilder.Append(nextChar);
break;
case 'b':
stringBuilder.Append('\b');
break;
case 'f':
stringBuilder.Append('\f');
break;
case 'n':
stringBuilder.Append('\n');
break;
case 'r':
stringBuilder.Append('\r');
break;
case 't':
stringBuilder.Append('\t');
break;
case 'u':
{
char[] array = new char[4];
for (int i = 0; i < 4; i++)
{
array[i] = NextChar;
if (!IsHexDigit(array[i]))
{
return null;
}
}
stringBuilder.Append((char)Convert.ToInt32(new string(array), 16));
break;
}
}
break;
default:
stringBuilder.Append(nextChar);
break;
}
}
return stringBuilder.ToString();
}
private object ParseNumber()
{
string nextWord = NextWord;
if (nextWord.IndexOf('.') == -1 && nextWord.IndexOf('E') == -1 && nextWord.IndexOf('e') == -1)
{
long.TryParse(nextWord, NumberStyles.Any, CultureInfo.InvariantCulture, out var result);
return result;
}
double.TryParse(nextWord, NumberStyles.Any, CultureInfo.InvariantCulture, out var result2);
return result2;
}
private void EatWhitespace()
{
while (char.IsWhiteSpace(PeekChar))
{
json.Read();
if (json.Peek() == -1)
{
break;
}
}
}
}
private sealed class Serializer
{
private StringBuilder builder;
private Serializer()
{
builder = new StringBuilder();
}
public static string Serialize(object obj)
{
Serializer serializer = new Serializer();
serializer.SerializeValue(obj);
return serializer.builder.ToString();
}
private void SerializeValue(object value)
{
if (value == null)
{
builder.Append("null");
}
else if (value is string str)
{
SerializeString(str);
}
else if (value is bool)
{
builder.Append(((bool)value) ? "true" : "false");
}
else if (value is IList anArray)
{
SerializeArray(anArray);
}
else if (value is IDictionary obj)
{
SerializeObject(obj);
}
else if (value is char)
{
SerializeString(new string((char)value, 1));
}
else
{
SerializeOther(value);
}
}
private void SerializeObject(IDictionary obj)
{
bool flag = true;
builder.Append('{');
foreach (object key in obj.Keys)
{
if (!flag)
{
builder.Append(',');
}
SerializeString(key.ToString());
builder.Append(':');
SerializeValue(obj[key]);
flag = false;
}
builder.Append('}');
}
private void SerializeArray(IList anArray)
{
builder.Append('[');
bool flag = true;
for (int i = 0; i < anArray.Count; i++)
{
object value = anArray[i];
if (!flag)
{
builder.Append(',');
}
SerializeValue(value);
flag = false;
}
builder.Append(']');
}
private void SerializeString(string str)
{
builder.Append('"');
char[] array = str.ToCharArray();
foreach (char c in array)
{
switch (c)
{
case '"':
builder.Append("\\\"");
continue;
case '\\':
builder.Append("\\\\");
continue;
case '\b':
builder.Append("\\b");
continue;
case '\f':
builder.Append("\\f");
continue;
case '\n':
builder.Append("\\n");
continue;
case '\r':
builder.Append("\\r");
continue;
case '\t':
builder.Append("\\t");
continue;
}
int num = Convert.ToInt32(c);
if (num >= 32 && num <= 126)
{
builder.Append(c);
continue;
}
builder.Append("\\u");
builder.Append(num.ToString("x4"));
}
builder.Append('"');
}
private void SerializeOther(object value)
{
if (value is float)
{
builder.Append(((float)value).ToString("R", CultureInfo.InvariantCulture));
}
else if (value is int || value is uint || value is long || value is sbyte || value is byte || value is short || value is ushort || value is ulong)
{
builder.Append(value);
}
else if (value is double || value is decimal)
{
builder.Append(Convert.ToDouble(value).ToString("R", CultureInfo.InvariantCulture));
}
else
{
SerializeString(value.ToString());
}
}
}
public static object Deserialize(string json)
{
if (json == null)
{
return null;
}
return Parser.Parse(json);
}
public static string Serialize(object obj)
{
return Serializer.Serialize(obj);
}
}
}
namespace AbilityApi
{
public class Api
{
public class AbilityTextureMetaData
{
public Vector2 BackroundTopLeftCourner = default(Vector2);
public Vector2 BackroundSize = default(Vector2);
public Vector2 IconTopLeftCourner = default(Vector2);
public Vector2 IconSize = default(Vector2);
public Vector2 TotalSize = default(Vector2);
}
public static List<Texture2D> CustomAbilityTexstures = new List<Texture2D>();
public static Dictionary<NamedSprite, List<NamedSprite>> CustomAbilitySpritesWithBackrounds = new Dictionary<NamedSprite, List<NamedSprite>>();
public static List<NamedSprite> Sprites = new List<NamedSprite>();
public static AbilityGrid abilityGrid;
public static T ConstructInstantAbility<T>(string name) where T : MonoUpdatable
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Expected O, but got Unknown
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
GameObject val = new GameObject(name);
Object.DontDestroyOnLoad((Object)(object)val);
InstantAbility val2 = val.AddComponent<InstantAbility>();
val.AddComponent<FixTransform>();
MonoUpdatable val3 = (MonoUpdatable)(object)val.AddComponent<T>();
if ((Object)(object)val3 == (Object)null)
{
Object.Destroy((Object)(object)val);
throw new MissingReferenceException("Invalid type was fed to ConstructInstantAbility");
}
return (T)(object)val3;
}
public static Texture2D LoadImage(string path)
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Expected O, but got Unknown
byte[] array = File.ReadAllBytes(path);
Texture2D val = new Texture2D(1, 1);
ImageConversion.LoadImage(val, array);
return val;
}
public static void RegisterNamedSprites(NamedSprite namedSprite, bool IsOffensiveAbility)
{
//IL_0011: 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_0018: 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_0033: 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_006a: 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_00ab: Unknown result type (might be due to invalid IL or missing references)
//IL_00db: Unknown result type (might be due to invalid IL or missing references)
//IL_00ea: 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_0100: Unknown result type (might be due to invalid IL or missing references)
//IL_010d: Unknown result type (might be due to invalid IL or missing references)
//IL_0135: Unknown result type (might be due to invalid IL or missing references)
//IL_0142: Unknown result type (might be due to invalid IL or missing references)
foreach (NamedSprite sprite in Sprites)
{
if (sprite.name == namedSprite.name)
{
throw new Exception("ERROR: ABILITY WITH NAME " + namedSprite.name + " ALREADY EXSITS! NOT CREATING ABILITY!");
}
}
((Object)namedSprite.associatedGameObject).name = namedSprite.name;
CustomAbilityTexstures.Add(namedSprite.sprite.texture);
List<NamedSprite> list = new List<NamedSprite>();
NamedSprite item = default(NamedSprite);
foreach (Texture2D backroundSprite in Plugin.BackroundSprites)
{
Texture2D val = OverlayBackround(namedSprite.sprite.texture, backroundSprite);
Sprite val2 = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
((NamedSprite)(ref item))..ctor(namedSprite.name, val2, namedSprite.associatedGameObject, IsOffensiveAbility);
list.Add(item);
}
CustomAbilitySpritesWithBackrounds.Add(namedSprite, list);
Sprites.Add(namedSprite);
}
public static Texture2D OverlayBackround(Texture2D ability, Texture2D backround)
{
//IL_0011: 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_0155: Unknown result type (might be due to invalid IL or missing references)
//IL_01af: Unknown result type (might be due to invalid IL or missing references)
//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
//IL_0204: Unknown result type (might be due to invalid IL or missing references)
//IL_020c: 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_0213: Unknown result type (might be due to invalid IL or missing references)
//IL_023b: Unknown result type (might be due to invalid IL or missing references)
//IL_0231: Unknown result type (might be due to invalid IL or missing references)
//IL_0233: Unknown result type (might be due to invalid IL or missing references)
//IL_026b: Unknown result type (might be due to invalid IL or missing references)
//IL_026d: Unknown result type (might be due to invalid IL or missing references)
//IL_0253: Unknown result type (might be due to invalid IL or missing references)
//IL_0255: Unknown result type (might be due to invalid IL or missing references)
//IL_0257: 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)
Color32[,] array = Texture2DTo2DArray(ability);
Color32[,] array2 = Texture2DTo2DArray(backround);
Vector2Int val = default(Vector2Int);
if (((Texture)ability).width > ((Texture)backround).width)
{
((Vector2Int)(ref val)).x = ((Texture)ability).width;
}
else
{
((Vector2Int)(ref val)).x = ((Texture)backround).width;
}
if (((Texture)ability).height > ((Texture)backround).height)
{
((Vector2Int)(ref val)).y = ((Texture)ability).height;
}
else
{
((Vector2Int)(ref val)).y = ((Texture)backround).height;
}
Vector2Int val2 = default(Vector2Int);
((Vector2Int)(ref val2))..ctor(((Vector2Int)(ref val)).x / 2, ((Vector2Int)(ref val)).y / 2);
Vector2Int val3 = default(Vector2Int);
((Vector2Int)(ref val3))..ctor(((Vector2Int)(ref val2)).x - ((Texture)ability).width / 2, ((Vector2Int)(ref val2)).y - ((Texture)ability).height / 2);
Vector2Int val4 = default(Vector2Int);
((Vector2Int)(ref val4))..ctor(((Vector2Int)(ref val2)).x - ((Texture)backround).width / 2, ((Vector2Int)(ref val2)).y - ((Texture)backround).height / 2);
Color32[,] array3 = new Color32[((Vector2Int)(ref val)).x, ((Vector2Int)(ref val)).y];
Color32[,] array4 = new Color32[((Vector2Int)(ref val)).x, ((Vector2Int)(ref val)).y];
Color32[,] array5 = new Color32[((Vector2Int)(ref val)).x, ((Vector2Int)(ref val)).y];
for (int i = 0; i < ((Texture)ability).width; i++)
{
for (int j = 0; j < ((Texture)ability).height; j++)
{
array4[i + ((Vector2Int)(ref val3)).x, j + ((Vector2Int)(ref val3)).y] = array[i, j];
}
}
for (int k = 0; k < ((Texture)backround).width; k++)
{
for (int l = 0; l < ((Texture)backround).height; l++)
{
array5[k + ((Vector2Int)(ref val4)).x, l + ((Vector2Int)(ref val4)).y] = array2[k, l];
}
}
for (int m = 0; m < ((Vector2Int)(ref val)).x; m++)
{
for (int n = 0; n < ((Vector2Int)(ref val)).y; n++)
{
Color32 val5 = array4[m, n];
Color32 val6 = array5[m, n];
if (val5.a >= 160)
{
array3[m, n] = val5;
}
else if (val6.a > 50)
{
array3[m, n] = MixColor32(val6, val5);
}
else
{
array3[m, n] = val6;
}
}
}
return TwoArrayToTexture2D(array3, ((Vector2Int)(ref val)).x, ((Vector2Int)(ref val)).y);
}
private static Color32 MixColor32(Color32 background, Color32 overlay)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: 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)
//IL_004a: 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_006a: 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_008a: Unknown result type (might be due to invalid IL or missing references)
//IL_00a8: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
float num = (float)(int)background.a / 255f;
float num2 = (float)(int)overlay.a / 255f;
float num3 = num + num2 * (1f - num);
byte b = (byte)Mathf.Clamp(num3 * 255f, 0f, 255f);
byte b2 = (byte)(((float)(int)overlay.r * num2 + (float)(int)background.r * num * (1f - num2)) / num3);
byte b3 = (byte)(((float)(int)overlay.g * num2 + (float)(int)background.g * num * (1f - num2)) / num3);
byte b4 = (byte)(((float)(int)overlay.b * num2 + (float)(int)background.b * num * (1f - num2)) / num3);
return new Color32(b2, b3, b4, b);
}
private static Color32[,] Texture2DTo2DArray(Texture2D texture)
{
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
Color32[] pixels = texture.GetPixels32();
Color32[,] array = new Color32[((Texture)texture).width, ((Texture)texture).height];
for (int i = 0; i < ((Texture)texture).width; i++)
{
for (int j = 0; j < ((Texture)texture).height; j++)
{
array[i, j] = pixels[i + j * ((Texture)texture).width];
}
}
return array;
}
private static Texture2D TwoArrayToTexture2D(Color32[,] ColorData2D, int width, int height)
{
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Expected O, but got Unknown
//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)
Color32[] array = (Color32[])(object)new Color32[width * height];
for (int i = 0; i < width; i++)
{
for (int j = 0; j < height; j++)
{
array[i + j * width] = ColorData2D[i, j];
}
}
Texture2D val = new Texture2D(width, height, (TextureFormat)5, false);
val.SetPixels32(array);
val.Apply();
return val;
}
}
internal class scroller
{
[HarmonyPatch(typeof(AbilityGrid), "Awake")]
public static class AbilityGridPatch
{
public static void Postfix(AbilityGrid __instance)
{
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
//IL_0083: Unknown result type (might be due to invalid IL or missing references)
//IL_008a: Expected O, but got Unknown
Transform transform = ((Component)__instance).gameObject.transform;
Transform val = transform.Find("bg");
if (!((Object)(object)transform.Find("scroller_content") == (Object)null))
{
return;
}
RectTransform component = ((Component)val).GetComponent<RectTransform>();
RectTransform component2 = ((Component)__instance).gameObject.GetComponent<RectTransform>();
component2.sizeDelta = component.sizeDelta;
component2.anchorMin = component.anchorMin;
component2.anchorMax = component.anchorMax;
component2.pivot = component.pivot;
GameObject val2 = new GameObject("scroller_content");
RectTransform content = val2.AddComponent<RectTransform>();
ScrollRect val3 = val2.AddComponent<ScrollRect>();
val2.transform.SetParent(transform, false);
IEnumerable<GameObject> enumerable = from child in ((Component)transform).GetComponentsInChildren<Transform>()
where ((Object)((Component)child).gameObject).name == "AbilityGridEntry(Clone)"
select ((Component)child).gameObject;
foreach (GameObject item in enumerable)
{
item.transform.SetParent(val2.transform, false);
}
val2.SetActive(true);
val3.content = content;
val3.viewport = ((Component)transform).GetComponent<RectTransform>();
val3.scrollSensitivity = -5f;
val3.horizontal = false;
val3.movementType = (MovementType)1;
val3.elasticity = 1f;
}
}
}
public class InstantTestAbility : MonoUpdatable
{
public void Awake()
{
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Expected O, but got Unknown
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Expected O, but got Unknown
Updater.RegisterUpdatable((MonoUpdatable)(object)this);
InstantAbility component = ((Component)this).GetComponent<InstantAbility>();
if (component.funcOnEnter == null)
{
component.funcOnEnter = new UnityEvent();
}
UnityEvent funcOnEnter = component.funcOnEnter;
funcOnEnter.AddListener(new UnityAction(CastAbility));
}
public void CastAbility()
{
AudioManager.Get().Play("startGame");
}
public override void Init()
{
}
public override void UpdateSim(Fix SimDeltaTime)
{
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "AbilityApi";
public const string PLUGIN_NAME = "AbilityApi";
public const string PLUGIN_VERSION = "1.0.0";
}
}
namespace AbilityApi.Internal
{
[BepInPlugin("com.David_Loves_JellyCar_Worlds.AbilityApi", "AbilityApi", "1.0.0")]
public class Plugin : BaseUnityPlugin
{
public struct CircleEntry
{
public Sprite sprite;
public Vector4 center;
}
[HarmonyPatch(typeof(AbilityReadyIndicator), "SetSprite")]
public static class SpriteCirclePatch
{
public static void Postfix(AbilityReadyIndicator __instance, ref Sprite sprite)
{
//IL_005a: 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)
if (Api.CustomAbilityTexstures.Contains(sprite.texture))
{
((Renderer)__instance.spriteRen).material.SetVector("_CircleExtents", new Vector4(0f, 0f, 0f, 0f));
}
else
{
((Renderer)__instance.spriteRen).material.SetVector("_CircleExtents", defaultExtents);
}
}
}
[HarmonyPatch(typeof(AbilityGrid), "Awake")]
public static class AbilityGridPatch
{
public static void Postfix(AbilityGrid __instance)
{
Api.abilityGrid = __instance;
if (__instance.abilityIcons.sprites.Count == defaultAbilityCount)
{
Debug.Log((object)"adding");
__instance.abilityIcons.sprites.AddRange(Api.Sprites);
}
}
}
[HarmonyPatch(typeof(AchievementHandler), "Awake")]
public static class AchievementHandlerPatch
{
public static void Postfix(AchievementHandler __instance)
{
if (__instance.abilityIcons.sprites.Count == defaultAbilityCount)
{
__instance.abilityIcons.sprites.AddRange(Api.Sprites);
}
}
}
[HarmonyPatch(typeof(CharacterStatsList), "TryStartNextLevel_online")]
public static class CharacterStatsListPatch
{
public static void Prefix(CharacterStatsList __instance)
{
if (__instance.abilityIcons.sprites.Count == defaultAbilityCount)
{
__instance.abilityIcons.sprites.AddRange(Api.Sprites);
}
}
}
[HarmonyPatch(typeof(DynamicAbilityPickup), "Awake")]
public static class DynamicAbilityPickupPatch
{
public static void Postfix(DynamicAbilityPickup __instance)
{
if (__instance.abilityIcons.sprites.Count == defaultAbilityCount)
{
__instance.abilityIcons.sprites.AddRange(Api.Sprites);
}
}
}
[HarmonyPatch(typeof(MidGameAbilitySelect), "Awake")]
public static class MidGameAbilitySelectPatch
{
public static void Postfix(MidGameAbilitySelect __instance)
{
if (__instance.AbilityIcons.sprites.Count == defaultAbilityCount)
{
__instance.AbilityIcons.sprites.AddRange(Api.Sprites);
__instance.localAbilityIcons.sprites.AddRange(Api.Sprites);
}
}
}
[HarmonyPatch(typeof(RandomAbility), "Awake")]
public static class RandomAbilityPatch
{
public static void Postfix(RandomAbility __instance)
{
if (__instance.abilityIcons.sprites.Count == defaultAbilityCount)
{
__instance.abilityIcons.sprites.AddRange(Api.Sprites);
}
}
}
[HarmonyPatch(typeof(SelectAbility), "Awake")]
public static class SelectAbilityPatch
{
public static void Postfix(SelectAbility __instance)
{
if (__instance.abilityIcons.sprites.Count == defaultAbilityCount)
{
__instance.abilityIcons.sprites.AddRange(Api.Sprites);
}
}
}
[HarmonyPatch(typeof(SlimeController), "Awake")]
public static class SlimeControllerPatch
{
public static void Postfix(SlimeController __instance)
{
if (__instance.abilityIconsFull.sprites.Count == defaultAbilityCount)
{
__instance.abilityIconsFull.sprites.AddRange(Api.Sprites);
}
}
}
[HarmonyPatch(typeof(SteamManager), "Awake")]
public static class SteamManagerPatch
{
public static void Postfix(SteamManager __instance)
{
if (__instance.abilityIconsFull.sprites.Count == defaultAbilityCount)
{
__instance.abilityIconsFull.sprites.AddRange(Api.Sprites);
}
}
}
[HarmonyPatch(typeof(CharacterSelectHandler_online), "InitPlayer")]
public static class CharacterSelectHandler_onlinePatch
{
public static Player playerToReturn;
public static bool Prefix(CharacterSelectHandler_online __instance, int id, byte color, byte team, byte ability1, byte ability2, byte ability3, int nrOfAbilities, PlayerColors playerColors)
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Expected O, but got Unknown
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_0134: Unknown result type (might be due to invalid IL or missing references)
//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
//IL_0106: Unknown result type (might be due to invalid IL or missing references)
//IL_008d: Unknown result type (might be due to invalid IL or missing references)
//IL_0098: Unknown result type (might be due to invalid IL or missing references)
//IL_00bb: 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_01ff: Unknown result type (might be due to invalid IL or missing references)
//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
//IL_0158: 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_0186: Unknown result type (might be due to invalid IL or missing references)
//IL_0191: Unknown result type (might be due to invalid IL or missing references)
//IL_027e: Unknown result type (might be due to invalid IL or missing references)
//IL_029c: Unknown result type (might be due to invalid IL or missing references)
//IL_0223: 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_0251: 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)
NamedSpriteList abilityIcons = SteamManager.instance.abilityIcons;
Player val = new Player();
val.Id = id;
val.Color = playerColors.playerColors[color].playerMaterial;
val.Team = team;
Debug.Log((object)$"team is {team}");
if (nrOfAbilities > 0)
{
if (Api.CustomAbilitySpritesWithBackrounds.ContainsKey(abilityIcons.sprites[ability1]))
{
val.Abilities.Add(Api.CustomAbilitySpritesWithBackrounds[abilityIcons.sprites[ability1]][team].associatedGameObject);
val.AbilityIcons.Add(Api.CustomAbilitySpritesWithBackrounds[abilityIcons.sprites[ability1]][team].sprite);
}
else
{
val.Abilities.Add(abilityIcons.sprites[ability1].associatedGameObject);
val.AbilityIcons.Add(abilityIcons.sprites[ability1].sprite);
}
}
if (nrOfAbilities > 1)
{
if (Api.CustomAbilitySpritesWithBackrounds.ContainsKey(abilityIcons.sprites[ability2]))
{
val.Abilities.Add(Api.CustomAbilitySpritesWithBackrounds[abilityIcons.sprites[ability2]][team].associatedGameObject);
val.AbilityIcons.Add(Api.CustomAbilitySpritesWithBackrounds[abilityIcons.sprites[ability2]][team].sprite);
}
else
{
val.Abilities.Add(abilityIcons.sprites[ability2].associatedGameObject);
val.AbilityIcons.Add(abilityIcons.sprites[ability2].sprite);
}
}
if (nrOfAbilities > 2)
{
if (Api.CustomAbilitySpritesWithBackrounds.ContainsKey(abilityIcons.sprites[ability3]))
{
val.Abilities.Add(Api.CustomAbilitySpritesWithBackrounds[abilityIcons.sprites[ability3]][team].associatedGameObject);
val.AbilityIcons.Add(Api.CustomAbilitySpritesWithBackrounds[abilityIcons.sprites[ability3]][team].sprite);
}
else
{
val.Abilities.Add(abilityIcons.sprites[ability3].associatedGameObject);
val.AbilityIcons.Add(abilityIcons.sprites[ability3].sprite);
}
}
val.IsLocalPlayer = false;
playerToReturn = val;
return false;
}
public static void Postfix(CharacterSelectHandler_online __instance, ref Player __result)
{
__result = playerToReturn;
}
}
[HarmonyPatch(typeof(CharacterSelectHandler), "TryStartGame_inner")]
public static class CharacterSelectHandlerPatch
{
public static bool Prefix(CharacterSelectHandler __instance)
{
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_0077: Invalid comparison between Unknown and I4
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
//IL_00a2: Expected O, but got Unknown
//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
//IL_00db: Unknown result type (might be due to invalid IL or missing references)
//IL_0112: Unknown result type (might be due to invalid IL or missing references)
//IL_0119: Unknown result type (might be due to invalid IL or missing references)
//IL_0135: Unknown result type (might be due to invalid IL or missing references)
//IL_013c: Unknown result type (might be due to invalid IL or missing references)
//IL_019e: Unknown result type (might be due to invalid IL or missing references)
//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
//IL_0159: Unknown result type (might be due to invalid IL or missing references)
//IL_0160: Unknown result type (might be due to invalid IL or missing references)
//IL_017c: Unknown result type (might be due to invalid IL or missing references)
//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
//IL_020f: Unknown result type (might be due to invalid IL or missing references)
//IL_0216: Unknown result type (might be due to invalid IL or missing references)
//IL_0278: Unknown result type (might be due to invalid IL or missing references)
//IL_027f: Unknown result type (might be due to invalid IL or missing references)
//IL_0233: Unknown result type (might be due to invalid IL or missing references)
//IL_023a: Unknown result type (might be due to invalid IL or missing references)
//IL_0256: Unknown result type (might be due to invalid IL or missing references)
//IL_036e: Unknown result type (might be due to invalid IL or missing references)
//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
//IL_0353: Unknown result type (might be due to invalid IL or missing references)
//IL_035a: Unknown result type (might be due to invalid IL or missing references)
//IL_030e: Unknown result type (might be due to invalid IL or missing references)
//IL_0315: Unknown result type (might be due to invalid IL or missing references)
//IL_0331: Unknown result type (might be due to invalid IL or missing references)
if (CharacterSelectHandler.startButtonAvailable && CharacterSelectHandler.allReadyForMoreThanOneFrame)
{
AudioManager val = AudioManager.Get();
if ((Object)(object)val != (Object)null)
{
val.Play("startGame");
}
CharacterSelectHandler.startButtonAvailable = false;
List<Player> list = PlayerHandler.Get().PlayerList();
list.Clear();
int num = 1;
NamedSpriteList abilityIcons = SteamManager.instance.abilityIcons;
for (int i = 0; i < __instance.characterSelectBoxes.Length; i++)
{
if ((int)__instance.characterSelectBoxes[i].menuState != 2)
{
continue;
}
PlayerInit playerInit = __instance.characterSelectBoxes[i].playerInit;
Player val2 = new Player(num, playerInit.team);
val2.Color = __instance.playerColors[playerInit.color].playerMaterial;
val2.UsesKeyboardAndMouse = playerInit.usesKeyboardMouse;
val2.CanUseAbilities = true;
val2.inputDevice = playerInit.inputDevice;
val2.Abilities = new List<GameObject>(3);
val2.AbilityIcons = new List<Sprite>(3);
val2.Abilities.Add(abilityIcons.sprites[playerInit.ability0].associatedGameObject);
if (Api.Sprites.Contains(abilityIcons.sprites[playerInit.ability0]))
{
List<NamedSprite> list2 = Api.CustomAbilitySpritesWithBackrounds[abilityIcons.sprites[playerInit.ability0]];
val2.AbilityIcons.Add(list2[val2.Team].sprite);
}
else
{
val2.AbilityIcons.Add(abilityIcons.sprites[playerInit.ability0].sprite);
}
Settings val3 = Settings.Get();
if ((Object)(object)val3 != (Object)null && val3.NumberOfAbilities > 1)
{
val2.Abilities.Add(abilityIcons.sprites[playerInit.ability1].associatedGameObject);
if (Api.Sprites.Contains(abilityIcons.sprites[playerInit.ability1]))
{
List<NamedSprite> list3 = Api.CustomAbilitySpritesWithBackrounds[abilityIcons.sprites[playerInit.ability1]];
val2.AbilityIcons.Add(list3[val2.Team].sprite);
}
else
{
val2.AbilityIcons.Add(abilityIcons.sprites[playerInit.ability1].sprite);
}
}
Settings val4 = Settings.Get();
if ((Object)(object)val4 != (Object)null && val4.NumberOfAbilities > 2)
{
val2.Abilities.Add(abilityIcons.sprites[playerInit.ability2].associatedGameObject);
if (Api.Sprites.Contains(abilityIcons.sprites[playerInit.ability2]))
{
List<NamedSprite> list4 = Api.CustomAbilitySpritesWithBackrounds[abilityIcons.sprites[playerInit.ability2]];
val2.AbilityIcons.Add(list4[val2.Team].sprite);
}
else
{
val2.AbilityIcons.Add(abilityIcons.sprites[playerInit.ability2].sprite);
}
}
val2.CustomKeyBinding = playerInit.keybindOverride;
num++;
list.Add(val2);
}
GameSession.Init();
SceneManager.LoadScene("Level1");
if (!WinnerTriangleCanvas.HasBeenSpawned)
{
SceneManager.LoadScene("winnerTriangle", (LoadSceneMode)1);
}
}
return false;
}
}
public static int defaultAbilityCount = 30;
public static Vector4 defaultExtents = new Vector4(0.04882813f, 0.04882813f, 0.08300781f, 0.9287109f);
public static string directoryToModFolder = "";
public static InstantTestAbility testAbilityPrefab;
public static Texture2D testAbilityTex;
public static Sprite testSprite;
public static List<Texture2D> BackroundSprites = new List<Texture2D>();
private void Awake()
{
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Expected O, but got Unknown
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin AbilityApi is loaded!");
Harmony val = new Harmony("com.David_Loves_JellyCar_Worlds.AbilityApi");
((BaseUnityPlugin)this).Logger.LogInfo((object)"harmany created");
val.PatchAll();
((BaseUnityPlugin)this).Logger.LogInfo((object)"AbilityApi Patch Compleate!");
new Harmony("AbilityApi").PatchAll(Assembly.GetExecutingAssembly());
directoryToModFolder = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
BackroundSprites.Add(Api.LoadImage(Path.Combine(directoryToModFolder, "BlueTeam.png")));
BackroundSprites.Add(Api.LoadImage(Path.Combine(directoryToModFolder, "OrangeTeam.png")));
BackroundSprites.Add(Api.LoadImage(Path.Combine(directoryToModFolder, "GreenTeam.png")));
BackroundSprites.Add(Api.LoadImage(Path.Combine(directoryToModFolder, "PinkTeam.png")));
}
}
}
