using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TerminalApi;
using TerminalApi.Classes;
using TerminalApi.Events;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("TerminalApi")]
[assembly: AssemblyCompany("dev.ammir.lethalasd")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("LethalASD")]
[assembly: AssemblyTitle("dev.ammir.lethalasd")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
public class MatrixSorter
{
public static readonly string SOURCE_CODE = "<color=#DCDCDC>#include <stdio.h></color>\r\n<color=#DCDCDC>#include <stdlib.h></color>\r\n<color=#DCDCDC>#include <time.h></color>\r\n<color=#DCDCDC>#include <unistd.h></color>\r\n\r\n<color=#FF6347>const</color> <color=#D3D3D3>int</color> SHELL_GAPS[3] = {7, 3, 1};\r\n\r\n<color=#FF6347>void</color> swap(<color=#D3D3D3>int</color> *a, <color=#D3D3D3>int</color> *b) {\r\n <color=#D3D3D3>int</color> temp = *a;\r\n *a = *b;\r\n *b = temp;\r\n}\r\n\r\n<color=#FF6347>void</color> shell_sort(<color=#D3D3D3>int</color> size, <color=#D3D3D3>int</color> **array) {\r\n <color=#FF6347>for</color> (<color=#D3D3D3>int</color> g = 0; g < sizeof(SHELL_GAPS) / sizeof(<color=#D3D3D3>int</color>); g++) {\r\n <color=#D3D3D3>int</color> gap = SHELL_GAPS[g];\r\n <color=#FF6347>for</color> (<color=#D3D3D3>int</color> i = gap; i < size; i++) { <color=#808080>// if gap is greater than size, we skip it</color>\r\n <color=#FF6347>for</color> (<color=#D3D3D3>int</color> j = i - gap; j >= 0; j -= gap) {\r\n <color=#D3D3D3>int</color> *diagonal_j = &array[j][size - j - 1];\r\n <color=#D3D3D3>int</color> *diagonal_j_next = &array[j + gap][size - (j + gap) - 1];\r\n \r\n <color=#FF6347>if</color> (*diagonal_j > *diagonal_j_next) { <color=#808080>// Condition that defines order</color>\r\n swap(diagonal_j, diagonal_j_next);\r\n }\r\n }\r\n }\r\n }\r\n}\r\n\r\n<color=#FF6347>void</color> print_matrix(<color=#D3D3D3>int</color> size, <color=#D3D3D3>int</color> **array) {\r\n <color=#FF6347>for</color> (<color=#D3D3D3>int</color> y = 0; y < size; y++) {\r\n <color=#FF6347>for</color> (<color=#D3D3D3>int</color> x = 0; x < size; x++) {\r\n <color=#FF6347>if</color> (x == size - y - 1) {\r\n <color=#D3D3D3>printf</color>(<color=#FFFF00>\"\\033[31m%3d\\033[0m \"</color>, array[y][x]); <color=#808080>// print in red</color>\r\n } <color=#FF6347>else</color> {\r\n <color=#D3D3D3>printf</color>(<color=#FFFF00>\"%3d \"</color>, array[y][x]);\r\n }\r\n }\r\n <color=#D3D3D3>printf</color>(<color=#FFFF00>\"\\n\"</color>);\r\n }\r\n}\r\n\r\n<color=#FF6347>int</color> main(<color=#D3D3D3>int</color> argc, <color=#D3D3D3>char</color> **argv) {\r\n <color=#D3D3D3>srand</color>(clock());\r\n\r\n <color=#D3D3D3>int</color> size;\r\n <color=#D3D3D3>int</color> **matrix;\r\n\r\n <color=#FF6347>if</color> (argc < 3) {\r\n <color=#FF6347>if</color> (argc == 1) {\r\n <color=#D3D3D3>printf</color>(<color=#FFFF00>\"Enter the size of the matrix: \"</color>);\r\n <color=#D3D3D3>scanf</color>(<color=#FFFF00>\"%d\"</color>, &size);\r\n } <color=#FF6347>else</color> {\r\n size = <color=#D3D3D3>atoi</color>(argv[1]);\r\n }\r\n \r\n matrix = <color=#D3D3D3>malloc</color>(sizeof(<color=#D3D3D3>int</color> *) * size);\r\n <color=#FF6347>for</color> (<color=#D3D3D3>int</color> y = 0; y < size; y++) {\r\n matrix[y] = <color=#D3D3D3>malloc</color>(size * sizeof(<color=#D3D3D3>int</color>));\r\n <color=#FF6347>for</color> (<color=#D3D3D3>int</color> x = 0; x < size; x++) {\r\n matrix[y][x] = rand() % 100 - 50;\r\n }\r\n }\r\n } <color=#FF6347>else</color> {\r\n size = <color=#D3D3D3>atoi</color>(argv[1]);\r\n <color=#FF6347>if</color> (argc < size * size + 2) {\r\n <color=#D3D3D3>printf</color>(<color=#FFFF00>\"Invalid argument count for matrix size %d\\n\"</color>, size);\r\n <color=#D3D3D3>return</color> 0;\r\n }\r\n \r\n matrix = <color=#D3D3D3>malloc</color>(sizeof(<color=#D3D3D3>int</color> *) * size);\r\n <color=#FF6347>for</color> (<color=#D3D3D3>int</color> i = 0; i < size*size; i++) {\r\n <color=#D3D3D3>int</color> y = i / size;\r\n <color=#D3D3D3>int</color> x = i % size;\r\n <color=#FF6347>if</color> (x == 0) {\r\n matrix[y] = <color=#D3D3D3>malloc</color>(size * sizeof(<color=#D3D3D3>int</color>));\r\n }\r\n matrix[y][x] = <color=#D3D3D3>atoi</color>(argv[i + 2]);\r\n }\r\n }\r\n\r\n <color=#D3D3D3>printf</color>(<color=#FFFF00>\"\\nInput matrix:\\n\"</color>);\r\n print_matrix(size, matrix);\r\n \r\n shell_sort(size, matrix);\r\n \r\n <color=#D3D3D3>printf</color>(<color=#FFFF00>\"\\nSorted matrix:\\n\"</color>);\r\n print_matrix(size, matrix);\r\n \r\n <color=#D3D3D3>free</color>(matrix);\r\n <color=#D3D3D3>return</color> 0;\r\n}\r\n\r\n// <color=#808080>vim: ts=4: sw=4:</color>\r\n";
private static readonly int[] ShellGaps = new int[3] { 7, 3, 1 };
public string Run(int size = 10, int[,]? initialMatrix = null)
{
int[,] matrix;
if (initialMatrix != null)
{
matrix = initialMatrix;
size = initialMatrix.GetLength(0);
}
else
{
matrix = GenerateRandomMatrix(size);
}
string text = "Input matrix:\n" + MatrixToString(matrix) + "\n";
ShellSortAntidiagonal(matrix, size);
return text + "Sorted matrix:\n" + MatrixToString(matrix) + "\n";
}
public string RunFromString(string? input = null)
{
if (input == null)
{
return Run();
}
string[] array = input.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (array.Length == 0)
{
return Run();
}
if (array.Length == 1)
{
if (!int.TryParse(array[0], out var result))
{
return "<color=#FF0000>Error: Invalid size argument.</color>\n\n";
}
return Run(result);
}
if (!int.TryParse(array[0], out var result2))
{
return "<color=#FF0000>Error: Invalid size argument.</color>\n\n";
}
if (array.Length < result2 * result2 + 1)
{
return $"<color=#FF0000>Error: The number of matrix elements does not match the expected size. Expected {result2}x{result2} matrix, but got {array.Length - 1} elements.</color>\n\n";
}
int[,] array2 = new int[result2, result2];
for (int i = 0; i < result2 * result2; i++)
{
if (!int.TryParse(array[i + 1], out array2[i / result2, i % result2]))
{
return "<color=#FF0000>Error: Invalid matrix element '" + array[i + 1] + "'.</color>\n\n";
}
}
return Run(result2, array2);
}
private void ShellSortAntidiagonal(int[,] matrix, int size)
{
int[] shellGaps = ShellGaps;
foreach (int num in shellGaps)
{
if (num >= size)
{
continue;
}
for (int j = num; j < size; j++)
{
for (int num2 = j - num; num2 >= 0; num2 -= num)
{
int num3 = num2;
int num4 = num2 + num;
int num5 = matrix[num3, size - num3 - 1];
int num6 = matrix[num4, size - num4 - 1];
if (num5 > num6)
{
matrix[num3, size - num3 - 1] = num6;
matrix[num4, size - num4 - 1] = num5;
}
}
}
}
}
private static int[,] GenerateRandomMatrix(int size)
{
Random random = new Random();
int[,] array = new int[size, size];
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
array[i, j] = random.Next(-50, 50);
}
}
return array;
}
private static string MatrixToString(int[,] matrix)
{
int length = matrix.GetLength(0);
string text = string.Empty;
for (int i = 0; i < length; i++)
{
for (int j = 0; j < length; j++)
{
text = ((j != length - i - 1) ? (text + $"{matrix[i, j],3} ") : (text + $"<color=#FF0000>{matrix[i, j],3}</color> "));
}
text += "\n";
}
return text;
}
}
namespace LethalASD
{
[BepInPlugin("dev.ammir.lethalasd", "LethalASD", "1.0.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class LethalASD : BaseUnityPlugin
{
public static MatrixSorter sorter = new MatrixSorter();
public static TerminalNode runNode = TerminalApi.CreateTerminalNode("", true, "");
public static LethalASD Instance { get; private set; } = null;
internal static ManualLogSource Logger { get; private set; } = null;
internal static Harmony? Harmony { get; set; }
private void Awake()
{
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Expected O, but got Unknown
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Expected O, but got Unknown
Logger = ((BaseUnityPlugin)this).Logger;
Instance = this;
Patch();
Events.TerminalParsedSentence += new TerminalParseSentenceEventHandler(OnTerminalCommandSend);
runNode.maxCharactersToType = 500;
TerminalKeyword val = TerminalApi.CreateTerminalKeyword("run", true, runNode);
TerminalApi.AddTerminalKeyword(val, new CommandInfo
{
Description = "[size] [matrix ]\nSorts a matrix",
Category = "Other"
});
TerminalKeyword val2 = TerminalApi.CreateTerminalKeyword("cat", true, (TerminalNode)null);
TerminalKeyword val3 = TerminalApi.CreateTerminalKeyword("main.c", false, (TerminalNode)null);
TerminalNode val4 = TerminalApi.CreateTerminalNode(MatrixSorter.SOURCE_CODE, true, "");
val2 = TerminalExtenstionMethods.AddCompatibleNoun(val2, val3, val4);
TerminalApi.AddTerminalKeyword(val2);
TerminalApi.AddTerminalKeyword(val3);
Logger.LogInfo((object)"dev.ammir.lethalasd v1.0.0 has loaded!");
}
private void OnTerminalCommandSend(object sender, TerminalParseSentenceEventArgs e)
{
string terminalInput = TerminalApi.GetTerminalInput();
if (terminalInput == "run")
{
runNode.displayText = sorter.RunFromString();
}
else if (terminalInput.StartsWith("run ") && terminalInput.Length >= 5)
{
string input = terminalInput.Split(" ", 2, StringSplitOptions.RemoveEmptyEntries)[1];
runNode.displayText = sorter.RunFromString(input);
}
}
internal static void Patch()
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Expected O, but got Unknown
if (Harmony == null)
{
Harmony = new Harmony("dev.ammir.lethalasd");
}
Logger.LogDebug((object)"Patching...");
Harmony.PatchAll();
Logger.LogDebug((object)"Finished patching!");
}
internal static void Unpatch()
{
Logger.LogDebug((object)"Unpatching...");
Harmony? harmony = Harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
Logger.LogDebug((object)"Finished unpatching!");
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "dev.ammir.lethalasd";
public const string PLUGIN_NAME = "LethalASD";
public const string PLUGIN_VERSION = "1.0.0";
}
}
namespace LethalASD.Patches
{
[HarmonyPatch(typeof(Terminal))]
public class TerminalPatch
{
[HarmonyPatch("ParsePlayerSentence")]
[HarmonyPostfix]
private static void HandleAllRunSubcommands(ref TerminalNode __result)
{
string terminalInput = TerminalApi.GetTerminalInput();
if (terminalInput.StartsWith("run"))
{
__result = LethalASD.runNode;
}
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
