Exiled 5 Transpiler tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d741a07c",
   "metadata": {},
   "source": [
    "## Transpilers in Exiled 5\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "598cf433-4400-4871-bc5b-2401c34e86f9",
   "metadata": {},
   "source": [
    "Make sure to run each cell that has code if you need it, but at least this first one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "2526d844-f456-479c-a67a-38204a669fc0",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "import json\n",
    "answers = []\n",
    "\n",
    "# You must allow this to be true to see ANY answers.\n",
    "global_show_answers = False\n",
    "\n",
    "with open('answers.json') as answer_file: \n",
    "    answers = json.load(answer_file)\n",
    "\n",
    "\n",
    "current_answer = None\n",
    "show_current_answer_validated = False\n",
    "\n",
    "def show_answers(allow_answer = False, solution_number = -1):\n",
    "    global show_current_answer_validated\n",
    "    global current_answer\n",
    "    \n",
    "    if global_show_answers and solution_number >= 0:\n",
    "        current_answer = ''.join(open(answers[\"answers\"][solution_number]).readlines())\n",
    "        show_current_answer_validated = True\n",
    "    elif not allow_answer:\n",
    "        print(\"Answer not shown due to first parameter\")\n",
    "        show_current_answer_validated = False\n",
    "        return\n",
    "    else:\n",
    "        print(\"Answer will not be show given the current configuration\")\n",
    "        show_current_answer_validated = False\n",
    "        \n",
    "\n",
    "#Test to hide code, for potential future example and try out yourself before seeing answer\n",
    "\n",
    "from IPython.display import HTML\n",
    "import random\n",
    "\n",
    "def hide_toggle(for_next=False):\n",
    "    this_cell = \"\"\"$('div.cell.code_cell.rendered.selected')\"\"\"\n",
    "    next_cell = this_cell + '.next()'\n",
    "\n",
    "    toggle_text = 'Toggle show/hide'  # text shown on toggle link\n",
    "    target_cell = this_cell  # target cell to control with toggle\n",
    "    js_hide_current = ''  # bit of JS to permanently hide code in current cell (only when toggling next cell)\n",
    "\n",
    "    if for_next:\n",
    "        target_cell = next_cell\n",
    "        toggle_text += ' next cell'\n",
    "        js_hide_current = this_cell + '.find(\"div.input\").hide();'\n",
    "\n",
    "    js_f_name = 'code_toggle_{}'.format(str(random.randint(1,2**64)))\n",
    "\n",
    "    html = \"\"\"\n",
    "        <script>\n",
    "            function {f_name}() {{\n",
    "                {cell_selector}.find('div.input').toggle();\n",
    "            }}\n",
    "\n",
    "            {js_hide_current}\n",
    "        </script>\n",
    "\n",
    "        <a href=\"javascript:{f_name}()\">{toggle_text}</a>\n",
    "    \"\"\".format(\n",
    "        f_name=js_f_name,\n",
    "        cell_selector=target_cell,\n",
    "        js_hide_current=js_hide_current, \n",
    "        toggle_text=toggle_text\n",
    "    )\n",
    "\n",
    "    return HTML(html)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d747120",
   "metadata": {},
   "source": [
    "### What are transpilers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61652d01",
   "metadata": {},
   "source": [
    "https://harmony.pardeike.net/articles/patching-transpiler.html\n",
    "\n",
    "A long story short, a transpiler is a method of placing code within existing code. They operate on a IL level basis (Think assembly). A detailed explanation of the general idea of transpilers can be found on the [Harmony Transpilers Page](https://harmony.pardeike.net/articles/patching-transpiler.html)\n",
    "\n",
    "However, this only goes over how they are used, not how they work. So let's dive deeper"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3fab7b84",
   "metadata": {},
   "source": [
    "### How they work under the cover\n",
    "\n",
    "Transpilers work by inserting IL code into the previously existing code through the instructions provided. So, take for example the Exiled example code \n",
    "\n",
    "\n",
    "```csharp\n",
    " public override void OnEnabled()\n",
    "{\n",
    "    RegisterEvents();\n",
    "\n",
    "    Log.Warn($\"I correctly read the string config, its value is: {Config.String}\");\n",
    "    Log.Warn($\"I correctly read the int config, its value is: {Config.Int}\");\n",
    "    Log.Warn($\"I correctly read the float config, its value is: {Config.Float}\");\n",
    "\n",
    "    base.OnEnabled();\n",
    "}\n",
    "```\n",
    "\n",
    "\n",
    "\n",
    "In C# we have a public function called onEnabled that is void\n",
    "We have a call to a function defined\n",
    "\n",
    "We have logger calls\n",
    "\n",
    "Then we have a base call, calling the base class onEnabled.\n",
    "\n",
    "Now let's look at the IL version of this "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "147e9d2f",
   "metadata": {},
   "source": [
    "```\n",
    "\t    /* 0x00000510 00           */ IL_0000: nop\n",
    "\t\t/* (44,13)-(44,30) \n",
    "\t\t/* 0x00000511 02           */ IL_0001: ldarg.0\n",
    "\t\t/* 0x00000512 281D000006   */ IL_0002: call      instance void Exiled.Example.Example::RegisterEvents()\n",
    "\t\t/* 0x00000517 00           */ IL_0007: nop\n",
    "\t\t/* (46,13)-(46,92) \n",
    "\t\t/* 0x00000518 72DF000070   */ IL_0008: ldstr     \"I correctly read the string config, its value is: \"\n",
    "\t\t/* 0x0000051D 02           */ IL_000D: ldarg.0\n",
    "\t\t/* 0x0000051E 282100000A   */ IL_000E: call      instance !0 class [Exiled.API]Exiled.API.Features.Plugin`1<class Exiled.Example.Config>::get_Config()\n",
    "\t\t/* 0x00000523 6F03000006   */ IL_0013: callvirt  instance string Exiled.Example.Config::get_String()\n",
    "\t\t/* 0x00000528 282200000A   */ IL_0018: call      string [mscorlib]System.String::Concat(string, string)\n",
    "\t\t/* 0x0000052D 282300000A   */ IL_001D: call      void [Exiled.API]Exiled.API.Features.Log::Warn(string)\n",
    "\t\t/* 0x00000532 00           */ IL_0022: nop\n",
    "\t\t/* (47,13)-(47,86) \n",
    "\t\t/* 0x00000533 7245010070   */ IL_0023: ldstr     \"I correctly read the int config, its value is: {0}\"\n",
    "\t\t/* 0x00000538 02           */ IL_0028: ldarg.0\n",
    "\t\t/* 0x00000539 282100000A   */ IL_0029: call      instance !0 class [Exiled.API]Exiled.API.Features.Plugin`1<class Exiled.Example.Config>::get_Config()\n",
    "\t\t/* 0x0000053E 6F05000006   */ IL_002E: callvirt  instance int32 Exiled.Example.Config::get_Int()\n",
    "\t\t/* 0x00000543 8C54000001   */ IL_0033: box       [mscorlib]System.Int32\n",
    "\t\t/* 0x00000548 282400000A   */ IL_0038: call      string [mscorlib]System.String::Format(string, object)\n",
    "\t\t/* 0x0000054D 282300000A   */ IL_003D: call      void [Exiled.API]Exiled.API.Features.Log::Warn(string)\n",
    "\t\t/* 0x00000552 00           */ IL_0042: nop\n",
    "\t\t/* (48,13)-(48,90) \n",
    "\t\t/* 0x00000553 72AB010070   */ IL_0043: ldstr     \"I correctly read the float config, its value is: {0}\"\n",
    "\t\t/* 0x00000558 02           */ IL_0048: ldarg.0\n",
    "\t\t/* 0x00000559 282100000A   */ IL_0049: call      instance !0 class [Exiled.API]Exiled.API.Features.Plugin`1<class Exiled.Example.Config>::get_Config()\n",
    "\t\t/* 0x0000055E 6F07000006   */ IL_004E: callvirt  instance float32 Exiled.Example.Config::get_Float()\n",
    "\t\t/* 0x00000563 8C55000001   */ IL_0053: box       [mscorlib]System.Single\n",
    "\t\t/* 0x00000568 282400000A   */ IL_0058: call      string [mscorlib]System.String::Format(string, object)\n",
    "\t\t/* 0x0000056D 282300000A   */ IL_005D: call      void [Exiled.API]Exiled.API.Features.Log::Warn(string)\n",
    "\t\t/* 0x00000572 00           */ IL_0062: nop\n",
    "\t\t/* (50,13)-(50,30) \n",
    "\t\t/* 0x00000573 02           */ IL_0063: ldarg.0\n",
    "\t\t/* 0x00000574 282500000A   */ IL_0064: call      instance void class [Exiled.API]Exiled.API.Features.Plugin`1<class Exiled.Example.Config>::OnEnabled()\n",
    "\t\t/* 0x00000579 00           */ IL_0069: nop\n",
    "\t\t/* (51,9)-(51,10) \n",
    "\t\t/* 0x0000057A 2A           */ IL_006A: ret\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c81d3d9",
   "metadata": {},
   "source": [
    "Woah, that's a lot to look at? Lot's of information in there. What does it mean, how does it work? Well, let's break it down"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7984fa44",
   "metadata": {},
   "source": [
    "### How to read IL code\n",
    "\n",
    "Before we begin, you must understand there are two types of structures we work with. \n",
    "\n",
    "1. Stack (Main Stack, MStack)\n",
    "*  Contains the order of events to occur in general programming terms. However, in this case it is the main stack that holds the reference to itself, and potentially results from function calls. This should be considered the _general storage_ you have limited access to. This contains usually at least (Instance, parameters**) \n",
    "2. Evaluation Stack (Temporary Stack, EStack)\n",
    "*  Contains information that is used when calling functions, it contains information passed onto it by the developer. This of this as a temporary array for you to use during the functions lifetime for _temporary storage_. \n",
    "\n",
    "\n",
    "`/* 0x00000510 00           */ IL_0000: nop ` \n",
    "\n",
    "**nop**: This is a no operation call, in functions they serve as a signal for the CPU to pass the next cycle. This means that the computer is told to either do nothing, something else, or anything. The computer processor simply moves to the next sequential instruction but it provides two things. \n",
    "\n",
    "1. A delay\n",
    "2. A breakpoint accessible location for debuggers.\n",
    "\n",
    "Overall, this is a non factor a majority of the time\n",
    "\n",
    "So at this point, our stack's look like\n",
    "\n",
    "EStack []\n",
    "\n",
    "`/* 0x00000511 02           */ IL_0001: ldarg.0`\n",
    "\n",
    "**ldarg.0**: This is an instruction you can read more about here [Opcodes.Ldarg_0](https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldarg_0?view=net-6.0). However, to give a general explanation - ldarg.0 is the instance which is usually a reference to itself. Keep in mind for static methods this is the first argument instead. This goes on the main stack we refer to earlier. \n",
    "\n",
    "So at this point, our stack's look like\n",
    "\n",
    "EStack [Instance]\n",
    "\n",
    "`/* 0x00000512 281D000006   */ IL_0002: call      instance void Exiled.Example.Example::RegisterEvents()` \n",
    "\n",
    "**call**: [Opcodes.Call](https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.call?view=net-6.0). Call is your way of invoking a non-virtual, static, or superclass method, i.e., the target of the call is not subject to overriding function. Since this function does not require any parameters as it is void, calls the function associated with our instance variable.\n",
    "\n",
    "`/* 0x00000517 00           */ IL_0007: nop` See nop above\n",
    "\n",
    "`/* 0x00000518 72DF000070   */ IL_0008: ldstr     \"I correctly read the string config, its value is: \"` \n",
    "**ldstr** [Opcodes.Ldstr](https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldstr?view=net-6.0). Ldstr is your way of loading a string to your stack to be used. \n",
    "\n",
    "So at this point, our stack's look like\n",
    "\n",
    "EStack [\"I correctly..\"]\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb041a8d",
   "metadata": {},
   "source": [
    "#### Now going forward, we have a lot of calls to underlying functions. I am not going to describe them all in detail but I will explain each new thing we encounter as we go forward\n",
    "\n",
    "`/* 0x0000051E 282100000A   */ IL_000E: call      instance !0 class [Exiled.API]Exiled.API.Features.Plugin`\n",
    "`1<class Exiled.Example.Config>::get_Config()`\n",
    "**call**: See above\n",
    "\n",
    "EStack [\"I correctly..\", Config]\n",
    "\n",
    "\n",
    "`/* 0x00000523 6F03000006   */ IL_0013: callvirt  instance string Exiled.Example.Config::get_String()`\n",
    "**callvirt** [Opcodes.Callvirt](https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.callvirt?view=net-6.0). Callvirt is your way of invoking a function that is virtual, non-static, non-superclass method. This means normally you would want to call your function utilizing this if you are doing any instance method calls. Otherwise, call is required.\n",
    "\n",
    "`/* 0x00000528 282200000A   */ IL_0018: call      string [mscorlib]System.String::Concat(string, string)\n",
    "/* 0x0000052D 282300000A   */ IL_001D: call      void [Exiled.API]Exiled.API.Features.Log::Warn(string)\n",
    "/* 0x00000532 00           */ IL_0022: nop\n",
    "/* (47,13)-(47,86) \n",
    "/* 0x00000533 7245010070   */ IL_0023: ldstr     \"I correctly read the int config, its value is: {0}\"\n",
    "/* 0x00000538 02           */ IL_0028: ldarg.0\n",
    "/* 0x00000539 282100000A   */ IL_0029: call      instance !0 class [Exiled.API]Exiled.API.Features.Plugin`\n",
    "`1<class Exiled.Example.Config>::get_Config()\n",
    "/* 0x0000053E 6F05000006   */ IL_002E: callvirt  instance int32 Exiled.Example.Config::get_Int()`\n",
    "\n",
    "So at this point, our stack's look like\n",
    "\n",
    "EStack [\"I correctly read the int config, its value is: {0}\", get_int() ]\n",
    "\n",
    "`/* 0x00000543 8C54000001   */ IL_0033: box      [mscorlib]System.Int32`\n",
    "**box** [Opcodes.Box](https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.box?view=net-6.0).\n",
    "Box converts a value type to an object reference. This means, we are converting the last item on the EStack to whatever type it is supposed to be, in this case, int32.\n",
    "\n",
    "`/* 0x00000548 282400000A   */ IL_0038: call     string [mscorlib]System.String::Format(string, object)\n",
    "/* 0x0000054D 282300000A   */ IL_003D: call      void [Exiled.API]Exiled.API.Features.Log::Warn(string)\n",
    "/* 0x00000552 00           */ IL_0042: nop\n",
    "/* (48,13)-(48,90) \n",
    "/* 0x00000553 72AB010070   */ IL_0043: ldstr     \"I correctly read the float config, its value is: {0}\"\n",
    "/* 0x00000558 02           */ IL_0048: ldarg.0\n",
    "/* 0x00000559 282100000A   */ IL_0049: call      instance !0 class [Exiled.API]Exiled.API.Features.Plugin`\n",
    "`1<class Exiled.Example.Config>::get_Config()\n",
    "/* 0x0000055E 6F07000006   */ IL_004E: callvirt  instance float32 Exiled.Example.Config::get_Float()\n",
    "/* 0x00000563 8C55000001   */ IL_0053: box       [mscorlib]System.Single\n",
    "/* 0x00000568 282400000A   */ IL_0058: call      string [mscorlib]System.String::Format(string, object)\n",
    "/* 0x0000056D 282300000A   */ IL_005D: call      void [Exiled.API]Exiled.API.Features.Log::Warn(string)`\n",
    "\n",
    "\n",
    "So at this point, our stack's look like\n",
    "\n",
    "EStack []\n",
    "\n",
    "`/* 0x00000572 00           */ IL_0062: nop\n",
    "/* (50,13)-(50,30) \n",
    "/* 0x00000573 02           */ IL_0063: ldarg.0\n",
    "/* 0x00000574 282500000A   */ IL_0064: call      instance void class [Exiled.API]Exiled.API.Features.Plugin`\n",
    "`1<class Exiled.Example.Config>::OnEnabled()\n",
    "/* 0x00000579 00           */ IL_0069: nop\n",
    "/* (51,9)-(51,10) \n",
    "/* 0x0000057A 2A           */ IL_006A: ret`\n",
    "\n",
    "So at this point, our stack's look like\n",
    "\n",
    "EStack []\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7366e638",
   "metadata": {},
   "source": [
    "## Woah that was a lot\n",
    "\n",
    "Yes, it is. So, let's take a break and think about what we just saw. We saw that we were able to store variables into a stack, and that calls were put into their own stack. We saw that information was pulled from our MStack to EStack to be used in function calls. We saw that we get nested levels of calls, and information associated.\n",
    "\n",
    "### Where do we go from here?\n",
    "\n",
    "Now, what we can do is use this information to insert instructions into various calls. However, let's start simple as we can and try to inject our own IL code by looking at Exiled"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "978adb4f",
   "metadata": {},
   "source": [
    "In order to achieve an inject, we need to use Harmony. This tool allows us to inject our own IL code into the assembly itself. Let's dive in\n",
    "\n",
    "[Example code](https://github.com/Exiled-Team/EXILED/blob/dev/Exiled.Events/Patches/Events/Player/ChangingGroup.cs)\n",
    "\n",
    "```csharp\n",
    "namespace Exiled.Events.Patches.Events.Player\n",
    "{\n",
    "#pragma warning disable SA1118\n",
    "    using System.Collections.Generic;\n",
    "    using System.Reflection.Emit;\n",
    "\n",
    "    using Exiled.Events.EventArgs;\n",
    "\n",
    "    using HarmonyLib;\n",
    "\n",
    "    using NorthwoodLib.Pools;\n",
    "\n",
    "    using UnityEngine;\n",
    "\n",
    "    using static HarmonyLib.AccessTools;\n",
    "\n",
    "    /// <summary>\n",
    "    /// Patches <see cref=\"ServerRoles.SetGroup(UserGroup, bool, bool, bool)\"/>.\n",
    "    /// Adds the <see cref=\"ChangingGroup\"/> event.\n",
    "    /// </summary>\n",
    "    [HarmonyPatch(typeof(ServerRoles), nameof(ServerRoles.SetGroup))]\n",
    "    internal static class ChangingGroup\n",
    "    {\n",
    "        private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)\n",
    "        {\n",
    "            List<CodeInstruction> newInstructions = ListPool<CodeInstruction>.Shared.Rent(instructions);\n",
    "\n",
    "            Label returnLabel = generator.DefineLabel();\n",
    "\n",
    "            int offset = 1;\n",
    "\n",
    "            int index = newInstructions.FindIndex(instruction => instruction.opcode == OpCodes.Ret) + offset;\n",
    "\n",
    "            // var ev = new ChangingGroupEventArgs(Player, UserGroup, true);\n",
    "            //\n",
    "            // if (!ev.IsAllowed)\n",
    "            //     return;\n",
    "            \n",
    "            newInstructions.InsertRange(index, new[]\n",
    "            {\n",
    "                new CodeInstruction(OpCodes.Ldarg_0).MoveLabelsFrom(newInstructions[index]),\n",
    "                new(OpCodes.Call, PropertyGetter(typeof(ServerRoles), nameof(ServerRoles.gameObject))),\n",
    "                new(OpCodes.Call, Method(typeof(API.Features.Player), nameof(API.Features.Player.Get), new[] { typeof(GameObject) })),\n",
    "                new(OpCodes.Ldarg_1),\n",
    "                new(OpCodes.Ldc_I4_1),\n",
    "                new(OpCodes.Newobj, GetDeclaredConstructors(typeof(ChangingGroupEventArgs))[0]),\n",
    "                new(OpCodes.Dup),\n",
    "                new(OpCodes.Call, Method(typeof(Handlers.Player), nameof(Handlers.Player.OnChangingGroup))),\n",
    "                new(OpCodes.Callvirt, PropertyGetter(typeof(ChangingGroupEventArgs), nameof(ChangingGroupEventArgs.IsAllowed))),\n",
    "                new(OpCodes.Brfalse_S, returnLabel),\n",
    "            });\n",
    "\n",
    "            newInstructions[newInstructions.Count - 1].labels.Add(returnLabel);\n",
    "\n",
    "            for (int z = 0; z < newInstructions.Count; z++)\n",
    "                yield return newInstructions[z];\n",
    "\n",
    "            ListPool<CodeInstruction>.Shared.Return(newInstructions);\n",
    "        }\n",
    "    }\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67d6dc20",
   "metadata": {},
   "source": [
    "Let's break it down the same way we did before\n",
    "\n",
    "`[HarmonyPatch(typeof(ServerRoles), nameof(ServerRoles.SetGroup))]`\n",
    "This is provided above your class (A class you can defined to whatever name you want) to tell harmony what we are going to modify. You can learn more here [Harmony patching](https://harmony.pardeike.net/articles/patching.html). However, the general idea is that you provide harmony the type of Class we are trying to modify, and the method we are trying to modify. Something to keep in mind is that you cannot change fields, or other types that are locked in, such as enums. See here [Harmony limitations](https://harmony.pardeike.net/articles/patching-edgecases.html)\n",
    "\n",
    "` internal static class ChangingGroup` \n",
    "Our class\n",
    "\n",
    "`private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)`\n",
    "Harmony requires all patch's be static, as it needs to be able to access it very early on. This means that whether it's a prefix, postfix, transpiler, or reverse-patch - they need to be static. The rest of the line includes:\n",
    "\n",
    "`IEnumerable` (Think advanced vector with iterator)\n",
    "CodeInstruction (A wrapper around OpCodes we saw above [Harmony CodeInstruction](https://harmony.pardeike.net/api/HarmonyLib.CodeInstruction.html), meaning we will need to use Harmony's version of OpCodes to mimic behavior)\n",
    "\n",
    "\n",
    "`Transpiler` (The type of patch method we want to use) \n",
    "\n",
    "`IEnumerable<CodeInstruction>` instructions (IEnumerable + Code Instruction) as parameter (The already compiled IL (opcode))\n",
    "    \n",
    "`ILGenerator generator` (Generator generates segments of method bodies. [Microsoft IL generated code])(https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.ilgenerator?view=net-6.0))\n",
    "\n",
    "\n",
    "    \n",
    "`List<CodeInstruction> newInstructions = ListPool<CodeInstruction>.Shared.Rent(instructions);`\n",
    "\n",
    "This will be the list of instructions we will be adding. ListPool is a generalized syncronized pool around IPool to allow safe behavior, renting some allocation on the queue. Additionally, we are copying over all the original instructions so that we can append/insert where needed\n",
    "\n",
    "`Label returnLabel = generator.DefineLabel();`\n",
    "\n",
    "This allows us to keep track of the original IL code meaning we can branch back over to it utilizing a label. Think GOTO \n",
    "\n",
    "`int offset = 1;`\n",
    "\n",
    "We normally do not want to overwrite the original ldarg.0 call.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cffc4ae3",
   "metadata": {},
   "source": [
    "`int index = newInstructions.FindIndex(instruction => instruction.opcode == OpCodes.Ret) + offset;`\n",
    "\n",
    "We are setting variable index to the first position where the instructions in the original code has a return. Meaning, if we look at the original SetGroup code, we can see where that is\n",
    "\n",
    "```csharp\n",
    "[ServerCallback]\n",
    "public void SetGroup(global::UserGroup group, bool ovr, bool byAdmin = false, bool disp = false)\n",
    "{\n",
    "if (!NetworkServer.active)\n",
    "{\n",
    "    return; <--- \n",
    "}\n",
    "```\n",
    "\n",
    "in IL it would look like\n",
    "\n",
    "```csharp\n",
    "/* 0x0004BC50 281300000A   */ IL_0000: call      bool [Mirror]Mirror.NetworkServer::get_active()\n",
    "/* 0x0004BC55 3A01000000   */ IL_0005: brtrue    IL_000B\n",
    "\n",
    "/* 0x0004BC5A 2A           */ IL_000A: ret <----\n",
    "```\n",
    "\n",
    "\n",
    "This means when we call that FindIndex, we can Hex A which is 10. Now that we know where we are, we will do the following:\n",
    "\n",
    "```csharp \n",
    "// var ev = new ChangingGroupEventArgs(Player, UserGroup, true);\n",
    "//\n",
    "// if (!ev.IsAllowed)\n",
    "//     return;\n",
    "```\n",
    "\n",
    "Now let's look at how it's done"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48f67048",
   "metadata": {},
   "source": [
    "The objective is to define a variable to use, and if the event called gets overriden by someone else (Exiled event += onEnabled adds a event catch) we will check if the event can be used, else return\n",
    "\n",
    "\n",
    "```csharp\n",
    "newInstructions.InsertRange(index, new[]\n",
    "{\n",
    "    new CodeInstruction(OpCodes.Ldarg_0).MoveLabelsFrom(newInstructions[index]),\n",
    "    new(OpCodes.Call, PropertyGetter(typeof(ServerRoles), nameof(ServerRoles.gameObject))),\n",
    "    new(OpCodes.Call, Method(typeof(API.Features.Player), nameof(API.Features.Player.Get), new[] { typeof(GameObject) })),\n",
    "    new(OpCodes.Ldarg_1),\n",
    "    new(OpCodes.Ldc_I4_1),\n",
    "    new(OpCodes.Newobj, GetDeclaredConstructors(typeof(ChangingGroupEventArgs))[0]),\n",
    "    new(OpCodes.Dup),\n",
    "    new(OpCodes.Call, Method(typeof(Handlers.Player), nameof(Handlers.Player.OnChangingGroup))),\n",
    "    new(OpCodes.Callvirt, PropertyGetter(typeof(ChangingGroupEventArgs), nameof(ChangingGroupEventArgs.IsAllowed))),\n",
    "    new(OpCodes.Brfalse_S, returnLabel),\n",
    "    new(OpCodes.Ret),\n",
    "});\n",
    "```\n",
    "\n",
    "In this code, we do the following\n",
    "\n",
    "`newInstructions.InsertRange` Our instructions to add `(index, new[] { });` and the instructions to add from {}\n",
    "\n",
    "`new CodeInstruction(OpCodes.Ldarg_0).MoveLabelsFrom(newInstructions[index]),` \n",
    "Our first instruction which is to copy over all of the previous branch label information from our current position in the original code (Remember our position is 1 + return meaning right after it)\n",
    "\n",
    "Now that we are after the if condition, and have all the branching information, we can then begin to add our own logic \n",
    "(Notice: This is not necessarily the case in all transpilers, see [049 Recall](https://github.com/Exiled-Team/EXILED/blob/dev/Exiled.Events/Patches/Events/Scp049/StartingAndFinishingRecall.cs)\n",
    "\n",
    "Which will be akin to `/* 0x00000511 02           */ IL_0001: ldarg.0`\n",
    "\n",
    "So now our stack's are:\n",
    "\n",
    "\n",
    "EStack [ServerGroup]\n",
    "\n",
    "`new(OpCodes.Call, PropertyGetter(typeof(ServerRoles), nameof(ServerRoles.gameObject))),`\n",
    "\n",
    "Remember our call earlier? This will resolve to the same thing, meaning what will happen is we will generate opcode in which it will use our EStack instance. This means it will look akin to\n",
    "\n",
    "`\n",
    "/* 0x00000512 281D000006   */ IL_0002: call      class [ServerRoles]ServerRoles.gameObject\n",
    "`\n",
    "\n",
    "\n",
    "So now our stack's are\n",
    "\n",
    "EStack [GameObject]\n",
    "\n",
    "`new(OpCodes.Call, Method(typeof(API.Features.Player), nameof(API.Features.Player.Get), new[] { typeof(GameObject) })),`\n",
    "\n",
    "Again, we now do another call, utilizing the object we just added to our stack to call the Player.Get function akin to\n",
    "\n",
    "`/* 0x00000512 281D000006   */ IL_0002: call      class [API.Features.Player)]API.Features.Player.Get(class)`\n",
    "\n",
    "So now our stack's are\n",
    "\n",
    "EStack [Player]\n",
    "\n",
    "Next steps are to load our arguments onto the eval stack \n",
    "\n",
    "`\n",
    "new(OpCodes.Ldarg_1),\n",
    "new(OpCodes.Ldc_I4_1),\n",
    "`\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "caa82361",
   "metadata": {},
   "source": [
    "This is the equivilant to \n",
    "\n",
    "` \n",
    "ldarg.1 Copy arguemnt 1 from MStack to EStack \n",
    "ldc.i4.1\n",
    "`\n",
    "\n",
    "So now our stack's are\n",
    "\n",
    "EStack [Player, User group, 1]\n",
    "\n",
    "`new(OpCodes.Newobj, GetDeclaredConstructors(typeof(ChangingGroupEventArgs))[0]),`\n",
    "\n",
    "Next to generate a new object with the parameters we've passed\n",
    "\n",
    "Player, 1, (Default value is in function call)\n",
    "\n",
    "Equivialant to \n",
    "`newobj    instance void [ChangingGroupEventArgs]Exiled.Events.EventArgs.ChangingGroupEventArgs::.ctor()`\n",
    "\n",
    "So now our stack's are\n",
    "\n",
    "\n",
    "EStack [ChangingGroupEventArgs]\n",
    "\n",
    "Thereafter we have \n",
    "`\n",
    "new(OpCodes.Dup),\n",
    "new(OpCodes.Call, Method(typeof(Handlers.Player), nameof(Handlers.Player.OnChangingGroup))),\n",
    "new(OpCodes.Callvirt, PropertyGetter(typeof(ChangingGroupEventArgs), nameof(ChangingGroupEventArgs.IsAllowed))),\n",
    "new(OpCodes.Brfalse_S, returnLabel),\n",
    "new(OpCodes.Ret)\n",
    "`\n",
    "\n",
    "Which breaks down to\n",
    "\n",
    "`new(OpCodes.Dup)` copy our last EStack item and duplicate it again on the EStack\n",
    "\n",
    "So now our stack are\n",
    "\n",
    "EStack [ChangingGroupEventArgs, ChangingGroupEventArgs]\n",
    "\n",
    "`new(OpCodes.Call, Method(typeof(Handlers.Player), nameof(Handlers.Player.OnChangingGroup))),`\n",
    "\n",
    "Calls the OnChangingGroup function, to make sure it gets the ev.IsAllowed event information\n",
    "\n",
    "`new(OpCodes.Callvirt, PropertyGetter(typeof(ChangingGroupEventArgs), nameof(ChangingGroupEventArgs.IsAllowed))),`\n",
    "\n",
    "Utilizes our last ChangingGroupEventArgs which may have been modified by the previous call *(which gets called by anyone who subscribed)* and saves it in MStack\n",
    "\n",
    "So now our stack's are\n",
    "\n",
    "EStack [ChangingGroupEventArgs, ChangingGroupEventArgs.IsAllowed]\n",
    "\n",
    "`\n",
    "new(OpCodes.Brfalse_S, returnLabel),\n",
    "new(OpCodes.Ret),\n",
    "`\n",
    "\n",
    "Now we check, if the isAllowed, our last item on the MStack is null then we will branch to the original logic. Otherwise, we will return\n",
    "\n",
    "So, all of this to do\n",
    "\n",
    "```csharp\n",
    "// var ev = new ChangingGroupEventArgs(Player, UserGroup, true);\n",
    "//\n",
    "// if (!ev.IsAllowed)\n",
    "//     return;\n",
    "\n",
    "```\n",
    "\n",
    "However, let's expand this. Utilizing what we learned earlier, let's try to add a print statement to this code. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c3f029b",
   "metadata": {},
   "source": [
    "Let's attempt to create the following\n",
    "```csharp\n",
    "// var ev = new ChangingGroupEventArgs(Player, UserGroup, true);\n",
    "//\n",
    "// if (!ev.IsAllowed){\n",
    "//     Log.Info(\"Changing group events were not allowed\");\n",
    "//     return;\n",
    "// }\n",
    "\n",
    "```\n",
    "\n",
    "\n",
    "\n",
    "In order to achieve this, we need to look back at our previous example of log. \n",
    "\n",
    "`* 0x00000518 72DF000070   */ IL_0008: ldstr     \"I correctly read the string config, its value is: \"\n",
    "        /* 0x0000051D 02           */ IL_000D: ldarg.0\n",
    "        /* 0x0000051E 282100000A   */ IL_000E: call      instance !0 class [Exiled.API]Exiled.API.Features.Plugin1<class Exiled.Example.Config>::get_Config()\n",
    "        /* 0x00000523 6F03000006   */ IL_0013: callvirt  instance string Exiled.Example.Config::get_String()\n",
    "        /* 0x00000528 282200000A   */ IL_0018: call      string [mscorlib]System.String::Concat(string, string)\n",
    "        /* 0x0000052D 282300000A   */ IL_001D: call      void [Exiled.API]Exiled.API.Features.Log::Warn(string)\n",
    "`\n",
    "\n",
    "And look back at the code written in Harmony's transpiler wrapper.\n",
    "\n",
    "\n",
    "```csharp\n",
    "    List<CodeInstruction> newInstructions = ListPool<CodeInstruction>.Shared.Rent(instructions);\n",
    "\n",
    "    Label returnLabel = generator.DefineLabel();\n",
    "\n",
    "    int offset = 1;\n",
    "\n",
    "    int index = newInstructions.FindIndex(instruction => instruction.opcode == OpCodes.Ret) + offset;\n",
    "\n",
    "    // var ev = new ChangingGroupEventArgs(Player, UserGroup, true);\n",
    "    //\n",
    "    // if (!ev.IsAllowed)\n",
    "    //     return;\n",
    "\n",
    "    newInstructions.InsertRange(index, new[]\n",
    "    {\n",
    "        new CodeInstruction(OpCodes.Ldarg_0).MoveLabelsFrom(newInstructions[index]),\n",
    "        new(OpCodes.Call, PropertyGetter(typeof(ServerRoles), nameof(ServerRoles.gameObject))),\n",
    "        new(OpCodes.Call, Method(typeof(API.Features.Player), nameof(API.Features.Player.Get), new[] { typeof(GameObject) })),\n",
    "        new(OpCodes.Ldarg_1),\n",
    "        new(OpCodes.Ldc_I4_1),\n",
    "        new(OpCodes.Newobj, GetDeclaredConstructors(typeof(ChangingGroupEventArgs))[0]),\n",
    "        new(OpCodes.Dup),\n",
    "        new(OpCodes.Call, Method(typeof(Handlers.Player), nameof(Handlers.Player.OnChangingGroup))),\n",
    "        new(OpCodes.Callvirt, PropertyGetter(typeof(ChangingGroupEventArgs), nameof(ChangingGroupEventArgs.IsAllowed))),\n",
    "        new(OpCodes.Brfalse_S, returnLabel),\n",
    "    });\n",
    "\n",
    "    newInstructions[newInstructions.Count - 1].labels.Add(returnLabel);\n",
    "\n",
    "    for (int z = 0; z < newInstructions.Count; z++)\n",
    "        yield return newInstructions[z];\n",
    "\n",
    "    ListPool<CodeInstruction>.Shared.Return(newInstructions);\n",
    "```\n",
    "\n",
    "Now I will leave the exercise to the reader but will put the answer below. Up to you to decide if you want to see the answer immediately or would rather try it out then look."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "90cb8ecf-cb8a-422e-9985-d2b7cba5f8ef",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": [
     "remote-output"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Answer will not be show given the current configuration\n"
     ]
    }
   ],
   "source": [
    "show_current_answer = True\n",
    "current_question = 0\n",
    "\n",
    "show_answers(show_current_answer, current_question)\n",
    "\n",
    "if(show_current_answer_validated):\n",
    "    print(current_answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce6df504",
   "metadata": {},
   "source": [
    "## General understanding \n",
    "\n",
    "Hopefully by this point, we now have a general understanding of how to generally look at, and read IL code, and Transpiler Harmony code. If not, please go back through and re-read. If it is still confusing or errors were made, open a PR and it'll be fixed. \n",
    "\n",
    "Assuming we have no major issues thus far, congratulations. You've now got a general basic grasp of how these two components, IL code, and Transpilers work. Going forward, the objective will be, I will give you scenarios to fill in your answers into for both IL, and Transpiler equivilants, and will evaluate the answer in that fashion. You can of course cheat but, no benefit will be gained. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59519762",
   "metadata": {},
   "source": [
    "### Now, let's go unto other examples..\n",
    "\n",
    "1. LoadsField, StoresField looking for calls\n",
    "2. Reference calls\n",
    "3. Try catch\n",
    "\n",
    "--- \n",
    "1. In this part, we will attempt to find a specific place to add our code by checking for a specific loading of a field. We will then insert code (Based on the context you will see), and verify it works\n",
    "2. In this part, we will attempt to call a function that has a reference variable. Meaning, an out or ref variable in a function.\n",
    "3. In this part, we will attempt to add a try catch, and then a try catch where we throw an exception.\n",
    "\n",
    "For now, here are the three sections of code we will evalute.\n",
    "\n",
    "1. https://github.com/Exiled-Team/EXILED/blob/2d315cf56be0b1e2481e0090495caa0e740cfda8/Exiled.Events/Patches/Events/Scp244/UpdateScp244.cs\n",
    "2. https://github.com/Exiled-Team/EXILED/blob/2d315cf56be0b1e2481e0090495caa0e740cfda8/Exiled.Events/Patches/Events/Scp330/InteractingScp330.cs\n",
    "3. https://github.com/Undid-Iridium/CleanupUtility/blob/main/CleanupUtility/Patches/ServerCreatePickupPatch.cs "
   ]
  },
  {
   "attachments": {
    "f19b97d2-b1c3-4a1a-b2ab-cf195ec5cb3c.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "6e392b66-bb68-4e65-9901-963e940d4c30",
   "metadata": {},
   "source": [
    "#### Part 1, LoadsField\n",
    "\n",
    "##### What is LoadsField?\n",
    "\n",
    "Well, LoadsField is a method that is provided by the CodeInstruction class (Which is provided by harmony). It allows you to specify a Field that you define to be compared against. So, for example:\n",
    "\n",
    "```csharp\n",
    "int index = newInstructions.FindIndex(instruction => instruction.LoadsField(Field(typeof(Scp244DeployablePickup), nameof(Scp244DeployablePickup._activationDot)))) + offset;\n",
    "```\n",
    "\n",
    "In this example, we are looking to find an instruction (The first one we can find (FindIndex)) where it attempts to load a field. Now, keep in mind with our previous exampples that we can define a Field (One without get; set;) with a Field method call. In this case, we do ```Field(typeof(Scp244DeployablePickup), nameof(Scp244DeployablePickup._activationDot))``` which resolves to `Scp244DeployablePickup._activationDot` Field. This means that when the opcode is being iterated on, it will compare the emit opcode type to a ldsfld or ldfld type. Then the opcode will be compared based on its operand type, meaning, it will compare if the operand (opcode object) resolves to the same Field we passed. Now, all of this happens under the cover, the only thing you, as a developer need to worry about it the following:\n",
    "\n",
    "1. Ensure your Field, is only a Field, if it is a get; set; you will need to modify your LoadsField to something else (You will see an example later on)\n",
    "2. If it is a Field then all you need to do is specify the specific type of Field, and LoadsField will identify the location for you.\n",
    "\n",
    "\n",
    "\n",
    "Here is a direct example from Exiled. In this example, you will see the usage of LoadsField, and code associated. \n",
    "\n",
    "```csharp\n",
    "// -----------------------------------------------------------------------\n",
    "// <copyright file=\"UpdateScp244.cs\" company=\"Exiled Team\">\n",
    "// Copyright (c) Exiled Team. All rights reserved.\n",
    "// Licensed under the CC BY-SA 3.0 license.\n",
    "// </copyright>\n",
    "// -----------------------------------------------------------------------\n",
    "\n",
    "namespace Exiled.Events.Patches.Events.Scp244\n",
    "{\n",
    "    /// <summary>\n",
    "    /// Patches <see cref=\"Scp244DeployablePickup\"/> to add missing event handler to the <see cref=\"Scp244DeployablePickup\"/>.\n",
    "    /// </summary>\n",
    "    [HarmonyPatch(typeof(Scp244DeployablePickup), nameof(Scp244DeployablePickup.UpdateRange))]\n",
    "    internal static class UpdateScp244\n",
    "    {\n",
    "        private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)\n",
    "        {\n",
    "            List<CodeInstruction> newInstructions = ListPool<CodeInstruction>.Shared.Rent(instructions);\n",
    "            \n",
    "            // Labels are for branching\n",
    "            Label normalProcessing = generator.DefineLabel();\n",
    "\n",
    "            // LocalBuilders should be considered the same as local variables.\n",
    "            LocalBuilder resultOfDotCheck = generator.DeclareLocal(typeof(int));\n",
    "\n",
    "#pragma warning disable SA1118 // Parameter should not span multiple lines\n",
    "\n",
    "            int offset = 1;\n",
    "            int index = newInstructions.FindIndex(instruction => instruction.LoadsField(Field(typeof(Scp244DeployablePickup), nameof(Scp244DeployablePickup._activationDot)))) + offset;\n",
    "\n",
    "            // Remove branching on dot result.\n",
    "            newInstructions.RemoveAt(index);\n",
    "```\n",
    "\n",
    "![UpdateRangeContext1.png](attachment:f19b97d2-b1c3-4a1a-b2ab-cf195ec5cb3c.png)\n",
    "\n",
    "```csharp\n",
    "            newInstructions.InsertRange(index, new[]\n",
    "            {\n",
    "                // EStack [Vector3Dot, ActivationDot], compare if left is less than right\n",
    "                new CodeInstruction(OpCodes.Clt),\n",
    "                \n",
    "                // EStack [Clt], store it in local variable we defined earlier.\n",
    "                new(OpCodes.Stloc, resultOfDotCheck.LocalIndex),\n",
    "\n",
    "                // EStack[], Store instance of program. Remember, non-static functions means arg0 is always instance.\n",
    "                new(OpCodes.Ldarg_0),\n",
    "            \n",
    "                // EStack[Instance], Load our saved clt value\n",
    "                new(OpCodes.Ldloc, resultOfDotCheck.LocalIndex),\n",
    "\n",
    "                // EStack[Instance, clt], now we will pass these two variables to a ctor (newobj creation) for OpeningScp244EventArgs. \n",
    "                // The reason why we need [0] is because we may have multiple constructors we could call so we need to be specific.\n",
    "                new(OpCodes.Newobj, GetDeclaredConstructors(typeof(OpeningScp244EventArgs]))[0]),\n",
    "\n",
    "                // EStack[OpeningScp244EventArgs], now we will copy OpeningScp244EventArgs again to allow us to use it twice\n",
    "                new(OpCodes.Dup),\n",
    "\n",
    "                // EStack[OpeningScp244EventArgs, OpeningScp244EventArgs], now we will call the OnOpeningScp244 func which returns nothing\n",
    "                // This call basically allows any delegate who is hooked (event https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/event)\n",
    "                new(OpCodes.Call, Method(typeof(Handlers.Scp244), nameof(Handlers.Scp244.OnOpeningScp244))),\n",
    "                \n",
    "                // EStack[OpeningScp244EventArgs] Now we use our last copy of the OpeningScp244EventArgs to check if the event can be allowed.\n",
    "                // See here how isAllowed is a field but has get; set;. meaning, we must call the instance with a propertygetter. The reason is\n",
    "                // because get; set is really just abstracted getter and setter functions, meaning it's a function call rather than an accessor.\n",
    "                new(OpCodes.Callvirt, PropertyGetter(typeof(OpeningScp244EventArgs), nameof(OpeningScp244EventArgs.IsAllowed))),\n",
    "\n",
    "                // Assuming event should be allowed, continue in the original if condition, otherwise, skip over.\n",
    "                new(OpCodes.Brfalse_S, normalProcessing),\n",
    "            });\n",
    "\n",
    "            int continueOffset = -1;\n",
    "            // Find the last instruction that calls state (which is after the if condition), and insert ourselves there.\n",
    "            int continueIndex = newInstructions.FindLastIndex(instruction => instruction.Calls(PropertyGetter(typeof(Scp244DeployablePickup), nameof(Scp244DeployablePickup.State)))) + continueOffset;\n",
    "\n",
    "            // Jumping over original NW logic. Placing label so we can jump here.\n",
    "            newInstructions[continueIndex].WithLabels(normalProcessing);\n",
    "\n",
    "            for (int z = 0; z < newInstructions.Count; z++)\n",
    "                yield return newInstructions[z];\n",
    "\n",
    "            ListPool<CodeInstruction>.Shared.Return(newInstructions);\n",
    "        }\n",
    "    }\n",
    "}\n",
    "```"
   ]
  },
  {
   "attachments": {
    "e60e71ed-0e9a-4d47-8b22-fd8bf6f3b7fb.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "9a01d6a7-03fd-4da5-a5ac-e1f2811be2e8",
   "metadata": {},
   "source": [
    "### Test your knowledge!\n",
    "\n",
    "How would you find this index\n",
    "\n",
    "![image.png](attachment:e60e71ed-0e9a-4d47-8b22-fd8bf6f3b7fb.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "472f44aa-129d-41c5-b577-b531b3937f0c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Answer will not be show given the current configuration\n"
     ]
    }
   ],
   "source": [
    "show_current_answer = True\n",
    "current_question = 1\n",
    "\n",
    "show_answers(show_current_answer, current_question)\n",
    "\n",
    "if(show_current_answer_validated):\n",
    "    print(current_answer)"
   ]
  },
  {
   "attachments": {
    "3e6b6df1-97a6-4b65-9372-1aef1e75ca1b.png": {
     "image/png": "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"
    },
    "5c8f8537-159c-4238-882d-6d220d070546.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "64398d98-f087-4997-b6d1-9744a41fe0d3",
   "metadata": {},
   "source": [
    "Now if you found that one, how would then find this one?\n",
    "![image.png](attachment:3e6b6df1-97a6-4b65-9372-1aef1e75ca1b.png)\n",
    "\n",
    "![image.png](attachment:5c8f8537-159c-4238-882d-6d220d070546.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "52dac7e1-9592-4f1f-9638-ca4725b0da03",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Answer will not be show given the current configuration\n"
     ]
    }
   ],
   "source": [
    "show_current_answer = True\n",
    "current_question = 2\n",
    "\n",
    "show_answers(show_current_answer, current_question)\n",
    "\n",
    "if(show_current_answer_validated):\n",
    "    print(current_answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1f75e75-6e72-4fc9-8a89-625584ee5a1f",
   "metadata": {},
   "source": [
    "#### Part 2, Reference Calls\n",
    "\n",
    "Now, let's pretend that you need to pass a variable, or a couple over to function x. Unfortunately, you need to keep any changes to the variables passed in func X, meaning it would be impractical to create a new local copy and return it. What would you do? Well in most languages there are pointers and syntax covered pointers called references. In this part we will dive into how to call a function with an out/ref parameter, and how it works. For this one, I will ONLY focus on the area we want to discuss, at this point, you should be able to read a majority if not all of the currnet lines. If you can not, go back over what we have learned. If that is still not sufficient, make an issue in the repo and I can add information.\n",
    "\n",
    "```csharp\n",
    "// -----------------------------------------------------------------------\n",
    "// <copyright file=\"InteractingScp330.cs\" company=\"Exiled Team\">\n",
    "// Copyright (c) Exiled Team. All rights reserved.\n",
    "// Licensed under the CC BY-SA 3.0 license.\n",
    "// </copyright>\n",
    "// -----------------------------------------------------------------------\n",
    "\n",
    "namespace Exiled.Events.Patches.Events.Scp330\n",
    "{\n",
    "    using System;\n",
    "#pragma warning disable SA1118\n",
    "#pragma warning disable SA1313\n",
    "\n",
    "\n",
    "    using static HarmonyLib.AccessTools;\n",
    "\n",
    "    /// <summary>\n",
    "    /// Patches the <see cref=\"Scp330Interobject.ServerInteract\"/> method to add the <see cref=\"Handlers.Scp330.InteractingScp330\"/> event.\n",
    "    /// </summary>\n",
    "    [HarmonyPatch(typeof(Scp330Interobject), nameof(Scp330Interobject.ServerInteract))]\n",
    "\n",
    "    public static class InteractingScp330\n",
    "    {\n",
    "        private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)\n",
    "        {\n",
    "            List<CodeInstruction> newInstructions = ListPool<CodeInstruction>.Shared.Rent(instructions);\n",
    "\n",
    "            Label continueProcessing = generator.DefineLabel();\n",
    "\n",
    "            Label shouldNotSever = generator.DefineLabel();\n",
    "\n",
    "            Label returnLabel = generator.DefineLabel();\n",
    "\n",
    "            LocalBuilder eventHandler = generator.DeclareLocal(typeof(InteractingScp330EventArgs));\n",
    "\n",
    "            // Remove original \"No scp can touch\" logic.\n",
    "            newInstructions.RemoveRange(0, 5);\n",
    "\n",
    "            // Find ServerPickupProcess, insert before it.\n",
    "            int offset = -3;\n",
    "            int index = newInstructions.FindLastIndex(instruction => instruction.Calls(Method(typeof(Scp330Bag), nameof(Scp330Bag.ServerProcessPickup)))) + offset;\n",
    "\n",
    "            newInstructions.InsertRange(index, new[]\n",
    "            {\n",
    "                new CodeInstruction(OpCodes.Ldarg_1).MoveLabelsFrom(newInstructions[index]),\n",
    "\n",
    "                new(OpCodes.Call, Method(typeof(Player), nameof(Player.Get), new[] { typeof(ReferenceHub) })),\n",
    "\n",
    "                new(OpCodes.Ldloc_2),\n",
    "\n",
    "                new(OpCodes.Newobj, GetDeclaredConstructors(typeof(InteractingScp330EventArgs))[0]),\n",
    "\n",
    "                new(OpCodes.Dup),\n",
    "\n",
    "                new(OpCodes.Stloc, eventHandler.LocalIndex),\n",
    "\n",
    "                new(OpCodes.Ldloc, eventHandler.LocalIndex),\n",
    "\n",
    "                new(OpCodes.Call, Method(typeof(Handlers.Scp330), nameof(Handlers.Scp330.OnInteractingScp330))),\n",
    "\n",
    "                new(OpCodes.Callvirt, PropertyGetter(typeof(InteractingScp330EventArgs), nameof(InteractingScp330EventArgs.IsAllowed))),\n",
    "\n",
    "                new(OpCodes.Brfalse, returnLabel),\n",
    "            });\n",
    "\n",
    "            // Logic to find the only ServerProcessPickup and replace with our own.\n",
    "            int removeServerProcessOffset = -2;\n",
    "            int removeServerProcessIndex = newInstructions.FindLastIndex(instruction => instruction.Calls(Method(typeof(Scp330Bag), nameof(Scp330Bag.ServerProcessPickup)))) + removeServerProcessOffset;\n",
    "\n",
    "            newInstructions.RemoveRange(removeServerProcessIndex, 3);\n",
    "\n",
    "            Label ignoreOverlay = generator.DefineLabel();\n",
    "\n",
    "            // Remove NW server process logic.\n",
    "            newInstructions.InsertRange(removeServerProcessIndex, new[]\n",
    "            {\n",
    "                // EStack[ReferenceHub], load the event handler <----------------------------------------------- Where we are starting for our ref example\n",
    "                new CodeInstruction(OpCodes.Ldloc, eventHandler),\n",
    "\n",
    "                // EStack[ReferenceHub, EV], get the field value of candy\n",
    "                new CodeInstruction(OpCodes.Callvirt, PropertyGetter(typeof(InteractingScp330EventArgs), nameof(InteractingScp330EventArgs.Candy))),\n",
    "\n",
    "                // EStack[ReferenceHub, Candy], load the local Scp330Bag by index; however, because we are passing by reference (out/ref), we must provide the\n",
    "                // address of the variable, rather than just the variable itself.\n",
    "                new CodeInstruction(OpCodes.Ldloca_S, 3),\n",
    "\n",
    "                // EStack[ReferenceHub, Candy, Scp330Bag], Call our method, and continue with basegame logic\n",
    "                new CodeInstruction(OpCodes.Call, Method(typeof(InteractingScp330), nameof(InteractingScp330.ServerProcessPickup), new[] { typeof(ReferenceHub), typeof(CandyKindID), typeof(Scp330Bag).MakeByRefType() })),\n",
    "            });\n",
    "\n",
    "            // This is to find the location of RpcMakeSound to remove the original code and add a new sever logic structure (Start point)\n",
    "            int addShouldSeverOffset = 1;\n",
    "            int addShouldSeverIndex = newInstructions.FindLastIndex(instruction => instruction.Calls(Method(typeof(Scp330Interobject), nameof(Scp330Interobject.RpcMakeSound)))) + addShouldSeverOffset;\n",
    "\n",
    "            // This is to find the location of the next return (End point)\n",
    "            int includeSameLine = 1;\n",
    "            int nextReturn = newInstructions.FindIndex(addShouldSeverIndex, instruction => instruction.opcode == OpCodes.Ret) + includeSameLine;\n",
    "\n",
    "            // Remove original code from after RpcMakeSound to next return and then fully replace it.\n",
    "            newInstructions.RemoveRange(addShouldSeverIndex, nextReturn - addShouldSeverIndex);\n",
    "\n",
    "            addShouldSeverIndex = newInstructions.FindLastIndex(instruction => instruction.Calls(Method(typeof(Scp330Interobject), nameof(Scp330Interobject.RpcMakeSound)))) + addShouldSeverOffset;\n",
    "\n",
    "            newInstructions.InsertRange(addShouldSeverIndex, new[]\n",
    "            {\n",
    "                new CodeInstruction(OpCodes.Ldloc, eventHandler.LocalIndex),\n",
    "\n",
    "                new (OpCodes.Callvirt, PropertyGetter(typeof(InteractingScp330EventArgs), nameof(InteractingScp330EventArgs.ShouldSever))),\n",
    "\n",
    "                new (OpCodes.Brfalse, shouldNotSever),\n",
    "\n",
    "                new CodeInstruction(OpCodes.Ldarg_1),\n",
    "\n",
    "                new CodeInstruction(OpCodes.Ldfld, Field(typeof(ReferenceHub), nameof(ReferenceHub.playerEffectsController))),\n",
    "\n",
    "                new CodeInstruction(OpCodes.Ldstr, nameof(SeveredHands)),\n",
    "\n",
    "                new CodeInstruction(OpCodes.Ldc_R4, 0f),\n",
    "\n",
    "                new CodeInstruction(OpCodes.Ldc_I4_0),\n",
    "\n",
    "                new CodeInstruction(OpCodes.Callvirt, Method(typeof(PlayerEffectsController), nameof(PlayerEffectsController.EnableByString), new[] { typeof(string), typeof(float), typeof(bool) })),\n",
    "\n",
    "                new CodeInstruction(OpCodes.Pop),\n",
    "\n",
    "                new CodeInstruction(OpCodes.Ret),\n",
    "            });\n",
    "\n",
    "            // This will let us jump to the taken candies code and lock until ldarg_0, meaning we allow base game logic handle candy adding.\n",
    "            int addTakenCandiesOffset = -1;\n",
    "\n",
    "            int addTakenCandiesIndex = newInstructions.FindLastIndex(instruction => instruction.LoadsField(Field(typeof(Scp330Interobject), nameof(Scp330Interobject._takenCandies)))) + addTakenCandiesOffset;\n",
    "            newInstructions[addTakenCandiesIndex].WithLabels(shouldNotSever);\n",
    "\n",
    "            newInstructions[newInstructions.Count - 1].labels.Add(returnLabel);\n",
    "\n",
    "            for (int z = 0; z < newInstructions.Count; z++)\n",
    "                yield return newInstructions[z];\n",
    "\n",
    "            ListPool<CodeInstruction>.Shared.Return(newInstructions);\n",
    "        }\n",
    "\n",
    "        private static bool ServerProcessPickup(ReferenceHub ply, CandyKindID candy, out Scp330Bag bag)\n",
    "        {\n",
    "            if (!Scp330Bag.TryGetBag(ply, out bag))\n",
    "            {\n",
    "                ply.inventory.ServerAddItem(ItemType.SCP330, ushort.MinValue);\n",
    "                if (!Scp330Bag.TryGetBag(ply, out bag))\n",
    "                {\n",
    "                    return false;\n",
    "                }\n",
    "\n",
    "                bag.Candies = new List<CandyKindID> { candy };\n",
    "                bag.ServerRefreshBag();\n",
    "                return true;\n",
    "            }\n",
    "\n",
    "            bool result = bag.TryAddSpecific(candy);\n",
    "\n",
    "            if (bag.AcquisitionAlreadyReceived)\n",
    "            {\n",
    "                bag.ServerRefreshBag();\n",
    "            }\n",
    "\n",
    "            return result;\n",
    "        }\n",
    "    }\n",
    "}\n",
    "```"
   ]
  },
  {
   "attachments": {
    "1d3ceeb3-5313-423c-88c7-6b83013d0b8d.png": {
     "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAAZCAYAAAAfd3hoAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAABP3SURBVHhe7Zz5VxTXtsf9S2imFlAEmWcEUWYwEkWNE4oJzgqKoKgYBgGBRoQWkUZAobERRFEENSAOTEZFUZTQnaysdV/uWvflZrgZbm4SzfedqjrdXd0U0Cgi3lc/fNaiau86dbqps79n73OqZ5mZmUFERERERGSyiAIiIiIiIvJaiAIiIiIiIvJaiAIiIiIiIvJaiAIiIiIiIvJaiAIiIiIiIvJaiAIiIiIiIvJazAoMDISIiMjMQalUIisrS9AmIjKTmBUcHAwREZGZQ1tbG3JycgRtIiIziVnlS53h7Cwi8pbx24BCVQd6BwYx2HEKS4V8RFhaWlpw8OBBQZvI/3P8UrFOXoXoAAHbtJCA6jtPMPioF9eVOZiV5iVc23q72ED6SQKckpfAStA+ncykvrxv2CMuPQF5KYGYL2inLM5Ay8MRaNQv8PBOO1pr0uAp5CfA/MwvUKL5CwpKQW2yoN9/E01NTUhMTBS0TZ45sIvJg2vMKlgK2mcYFq6Yk7wNTh/7C9unk5nUFxZrBNV+x46D0ubi0XbLTVgiu4DlGxeMtk0Z4chUtqKzfwgjGo3RIrp9EBxKTiC4qxFR/ZcQ3deAsCt5cF7jDAnf741xheNZJaLbD8FO0D4VLIL7VfIZmM9hRHBJJM9vOvoyMR9UyqHRNAgzlA9ZuPB1r4c5fLZuQ8vdSjwfYe6hwvCQAnea4rHCVsh/LPxR2dOAoc8SEC5oZwhG/vVnUKsfofmAD8wFfcbG3CEU7tGr4RnfgkNPRQGZPL7wyHiOZVknYCtoNw1JYCxcaysRdu8iN4666xF8fj/sA6wF/V8baQw8b1xCZM1GYftUMHc7FhjFBI5G+Cbx/KajL5NCgtnbenD08T+QuF9AJGwv4LDmFfKqd422TTk2CD12jScg9kvgfvkCKxrBF7LglrkNLqUyBN+5gMXla6Z4dj4dQdsRdklk9pBOPkd5OSL6lVhQxB07rnHh+c0MAXGNWwuZLIGlok0BzXAZLpVzx7K8lVg+X/i6yWOOoIwsDKgboH4qR1vdTnKPbahrO4Vnj/MgW2opcM1YmCAg686g5wsNHqi2w0HIbioBVdg/KArI5HlzAZEsJgH3DgmwPXVYWJ0Gl/QdcK+qQBg59j84xbPz6QjaVotgT+KAE/M5GsjY7ymDF3u8FXODeX4zTkAmYFoFhMFGLyDSzFJE9jcgMDfEYJYomW1Nsw8aaG8XYX6A1s7N8sPrt8Bae419KOaXyxF8q4HLYlhUWJDuq2/DQPW1nId/mhdtl8w8Y7bCp0WJyD5iI6IWokrFXA8LaufuG6Y6Cv+bZEZ0rwyehbkI6b2EqI58Xv84rJLzEdZfDY+V/POm90XisgQu5yoRTtqP7r+IiM9K4bHNg34vk+uLKbDZiEDWoc9SzuGzokgcaT6NYUYIhivRJvOHdWA82p+pMNAUa1BScko8jIfMNTJvmNmF4VyfCuqBT3HYbxyxkHrhsLIIA8MqLkN5ehKtpRFwY+2ccIzKlFgUqN+sbyeyuBMvNL2oXjVb37aOMKxo/RWKBw+xtuwrHB9+BYX6D5T0DGJllNTQd1wB8Ub0xZ9omeslyga+wZ6iNDhYUfvcQ9jZ/wplnZcNS2dL2pBF7llQmwoL9pwtPD+9j8yBP1BB2qoY/hW5LZcQ5EL9V9xGHi2lya+TiVbWEAppn4taz8NTe783hBOQfbCJrUVo8RMsVzxH7KnPEbozGVJL6mezm0yIjITBsQghikGEblpKjjnhiGWuHcVDBCyh10yIDRxqVGQMVsFrky3vvISNDezfNNBGXUmFjdbOzvIvYlFhiO4aycJ1cD9Pspg7Tfqx1lsJ9xX6NgzHIaW3Am4xtF0zC0h3piPwMxpfSCYUVB4Haym1s/dtwsKqo1jcQ/p0k0yGSytJbGtGxKW9+v6xWGPOyRrSxjHDyY3JfZHAPHwzvFvqSPvE1teIsJYczI+g38uk+jIec7DmBvfccfyJ/Zk8OyscfDuPkS+wQusnmQevnAGSwfzB2Yb/TZ7vevjacHaLT/pQqP4NaZdGUKL+C2Vdd5HQ9isZCy9R3KKAvbYdHlRAfOCkakD0Z1mwnzvaicMUAbGBXckZRPGyGGbG75S+GfaRdsRuAXNvX0hDouBcX4/oG5mYF7KAHDP4wsqBCoTLanjfaCbB+Az8ju+CS5kc4URIIhoTMZsdpNx9o65nwSF+DwLuXERIFblH9gmE99fDf78H1w5FWEBM7IuFH/luyADqPouAk0lwykiFbyt5eO/K4RLF+EyuL6YwloBI3T0QHbcZ7YPncb/9GO52p6OseC9aP1dCM5iNDF9X5LafhebxEaToMhYp4pWndO1ZrtiLXo0Sd08tNGjbEBskkGvU6nPoadmLEpKh1HecwYi6Es0H7IndEu6L/RAdHQMl+V8/79qNrdHMMYMXvHllsKTGQdKfy0hz47evhQoIeZCL+7/GrrJGbFR9g1Ly8Jbf60AAPyCPKyCO8NpTi3WyRqyTdyP13i84rfkdGaWbqDA4IkT5HSpe/A82LtVf51b0NU6qv8OOjzmxstl+HwXqV5D3DGFzCdOXv+HEyCsUNRZy2anUH67RKYi78W+c7tPgcPffkVR2GVvbfkC55mekHArQtf0mMAKSlHsdkRVDWFbUCt+NBfA5fJ8IyVNEbI3jJi4TCoglLJ0jYOO5Ht7ZxO+oAg6ezDFDGKy0AXcibNbA5xaZhddvHXsNxRQBsfCCSxOZYOmyGBobDm2ALSPQEiksF5KxF7kBPjfJ/ep20LFICPaCJe2vZNl+LCKxIKqjBJ7ZJINQniNCchHB8hjue2HvSwK0cifs9h9DGHk+A3I/hGNVHQn+5XCL4trhGENATOyLmQP5bjqJcNwqh3c++Sy5mVjYdRFR7emYw/hMqi/jYQ7bwNXwjCZx8dATyIwFROIOJ6bMu+w6PiUZSL7qOOvLEhWK2ayfBLP3PUExsZf0PEGCrAmbLnxDhOIVZKostsLECgixF6hOIKj672Ri9D32ZmQi4fZLMkafY7n2fjyogFAhOL8NUiMHPaYICPXpyME8XbYgBPUbo2xklUi+bJINBWRo63x2mHuK/KN7TsONDQC8+3rFw+8WzRiiycNllD2w7QkKiJbx+2IWmYIg8o8PzA7SrwP5fgK/rgvkXCA5nlxfTGEsAWHxWYsrT0jWMXAEB2hQZv1HTqJqnRlck49gQFODtqOunL9lICq7VXjRtR0x5NgnPQtPNJVo2MllH3YRHyKHls5ksg3YwvxvPT/C5cckk2leRTMOpp2FqO5twOPmlbzsZuISFisgA81I0c7iDaAC8sX/Yst6bcbhirDz36Pii38gYRXPd1IlrOVY1/EfnO7ugD89Zx57HdnDfyK3KpGKCnfvCpL9RDgwx4ux7OovqHg0gGhdX60QeO6fUAwMIJL10V+nUP8LSXs9uXNsZvInchRbqc+b0dR0CQeqHyO2vAvegfS81Ur45JFBLKvBPOZ4QgGh5960hKUVgqIIYTuDKQJCfSIbdumzBSG0foJlIyvYlVax2ZDHanrOYgHcLpMg3pnJzZB595WsP4JgmjGYpxcbZQ8MYwiIlnH7Qto8WEQmy1XwjNOvA5nHZyCkrwae68nxpPpiGlyQNxIQLeOWsObgo/aX5Hn/HOE042Aml2Gqf0Hx6HOEkWN+21YFX9HsRYpg5Q+GmQyPKRYQC1gnc+Wb6L4mhF2Tw7dkB+zD5+qDL7+tMYK2jUxB0kXDgM+JgHZGP30Cwl1LPo8A3GL8uxGQoRsfI9jYxmAXDuX9Bjxt24gAcmy5LAnd6jp0yTkx5gTkDJpTmIxQe2xUfvogCT26c4YYisUUCcizL7GaV3vmdl79hKQkZ73vuAJiC9ekq0i6+S2KnvyME4TiZ39C8aAXQTofKio9XVjIZDZse2T21ZBDZ2ibsaWPl/rzMegf7fNTNVYFac9NLU1NV5GuGkZsqQqOuvOOcNjTh9hTN+DB7Jx83wREQiaBbPmGjJ1eFUIuyeCZtw62zkaL8OMGbVs4qcj1BgGfioB2Rj9tAkKvNYoJHHQxfiYJiFUadj4weq61UHF4AwF5zRKW3QfwbOcLCIfEOxLzPj0InwuVCOtuJmKihP8BfiClbb03AnIW3jtpCsvD2o15+N+NgDyqjxptY5Fi47kyqF8ch5w8oGGlRRimfzN2u/j9uC9UwmJFgy8gteg6vYSWpfRELJzD+19PLCCbax9APXwThf5C9vEExKgkNI6AzCcBsphZh+i4j3imjCW7hqR7/zESEJKdFXwJufpHJO52xpzkJyiif3N2TkDkHe0I0ab/WiIiYKsrp9E+G7U9lbyugEh8yhE+1QLymiUsSeAeLKTBU+8rgUXUR5gvy8SClnOIYNY3u0ng5wfS901AumVwNooL0hA/WDFxdAYKyOkbLYbPNgMtc72BgFhgdl4ZmR00YlHJMpriG2MP+4qziL5TDKdF9NxC8gXdGS0gBrDlHmMfGrRv5cNR4D2Ud1LCGqMvZqFJCOxpwmJ57Bjfy2QFZDacvV1hZ84/Z8ibCQjJOj7Yga5hJuuIQcGNc7ryFWt3+hCND5kSmNEiOl9AqM9QxxYstaZ2QTgBGenbh01j+AXkXceQZoBkPPydb1poMDYoYdH1ijFKWCdaThkt5nGlJ8WDfoTogjyXbYwK8p6lSB5gso5iRJ3/gVe+YqAL8UTM1hov4BswHQJiQgnLej1884kwZJfqJj6Wyy9i6RgCsrzoHBy0C/CTQTIP8+uY3Zl18E2mZVFjrBazYyCq9YBOpMy355AxZywghrDlHmMfrRg17xGohrybEpZwX0ibJK5E9NXDL3WM7+WdCMhfKL0sF9g1a4flV38nz7caH+kqSIa8gYAQtNt4yQcOu5IPjxxmkSsRHlVF8D7IBXLrg0UIZ+wXM+DCLCYrCxBAMpDIq5mYH8u8K+KIublZ8CrcxS2QZaTAq6GGCFMTFsnCDcpYurYu5dDF9kS47KaCYeIi+vhB29RtvBP0hQiMQ00du1DHt3vId8GOzdYmJyCRB6tw+eoVVB2KGLNcKCwg5nDwJ0GOXURvwEDzWjYjCPUWCnburHCMDJbj4ZBxtiG0jTcBparjeKbbQSXFmtPH8UKjwouHBVCVMesjW6FQJuOIQZ9otqOuw8OONJQx6yjFO5C/zUnvE1yIm0MaPL9RiEWjRJMG4xc/Q9anXURnFq4FFtHN1iL+9p9QDP+AtJoWrCvuxI7yAjJDt0JA9beoGP4nkrJ2w3PZQaxUfon0zm9xcvArJBzeD2fdor4jQolwKJ59jwIiRkWNx2j5ikMa14ns4b9Q8fwHHD7fxi7Kx1X2Y8uhGNbOvZPCLaIrHg5gKTN7Cw0YY4v7B5B3DXPlu0luwTZpEd3MGU4pDxBb8RjhyXK4faLC4tRrJAN5iqjUAtg7a58La9gmdJBrB7EkQwnPdXlwW3+czNaZ9TvD+46Fbhtv3wUEq47AjRnbR1LhVV8IVzaQS8nkso61L67axy4mB1QXkwykGSG1iZjDvCtiFQKn8qNwz+bGoFPOYfhdY3Z3KeG9nV/G4rVVSxfbj+wjY5b2xaRF9AmCtqnbeCfoCysw7ReN7OR7KVzNZWtTJSC2AXCj2QK3iP4Sh07Q7GEBr8xrHokNt16SYP8LjjZ3cptKTl7G0jDObvFJL/LVf5Ex9D0OnrvG2c88wFb6TsmkBcQmnicgBIlLJPkny/UvEpIPH9FZCf9jMdwXYuEFh/LT3HZWEtx9UtewwZOp+3EZRiBcm/jbd5sRebsGgRXbYGc8iCxcMVd2AiF36YtJ5F4hVXG6wWjKNt7xgzbno69L6jF8kXDivphJPWFfKMOiTu33Qj7XjVw4smWZyQnIgh0n0NDSiNLdfmO+VCcsIPORfqV61JrEWJlIYG4uEQTiwytf6bFE0N4ktPVWsduAmXbUw2fx6F4Gjn1IfSznYV1eGm49qMUIvZf6hRzV8fx2CPOCcKy5BE/Y7b7ET61Ez5lQno8UW2rvkzaeo0eVjjB7c55NW8L6GtsUL3RbYgW38RJsNrTjMN1iy/jJ73YikLF5ZGFz5084xQwO9W/Ia7mEJYXaN9i/x46N+jakm/u4QWRQvtJiBfuNDUjs+hFlRMTY+rD6d2RXciUB47fiWcbMROJR0z8Cze0yBI2TbQph0jZeBvvd8Mn6HMsUjNC0wD2CPMPsNl2jLMQqCs6JN7GkbIhu4yUis3Oz3j4hEpiHxnFbcLUvEvY1Irz9JDx3uXM+85bBvYnbzhrVcQIucbtI8OTGEpthzEmAL3/7LhtbTsMvb8VoAZ4bDufaSoT3UF9m91KmdkJnyjbeCYI266PtBx+jFwkn7AvBKRrOVeUI1X4v5N7hF5K4Ut4UCQgX2I2eO8rp1moDX0lwKXbe+gllzDPO+BAx2ZOqtZvDbuNl7LvHt/+GzFNbWPukBMRhDUqvP8GsYm2KLPJfhTRsA64OnMdgaxy7mC7kM21II5B9+QERKw37cyZPrx+nfdIKiOEayNvE3CMD2+79IZDhTDUpaH6mIZliyvg/8yLA1L5IKCIylaxC+a2nGNaQsawZfle/hSXyVnANRaYiDS3XT+DxCFOiykfRpN4sf5tI4bIqBcerG3FV91tY0yQgc9cgqqgbe9v+hoIhkuUMf4sdO+gW3LfFslO4M6zB7bKgSf98iyggIjMX7rewLpzJQfKHToYlLJH3HGYhXF2HpwNl6Gjcii3jvWk+I5gmAWEX4P+AfPBHZLd2ISZijrDfVLL9PB6pH6ExyUHYPg6igIi8L8zy8PCAiIjIzOHKlStIT08XtImIzBw88H/LbUyTAFZ4BgAAAABJRU5ErkJggg=="
    },
    "cd7d22f3-3988-4fe5-8a74-eb8b88d3a8b9.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "8c85c6d7-df9e-4a3c-a3f4-8ff9bb0b96de",
   "metadata": {},
   "source": [
    "### Test your knowledge!\n",
    "\n",
    "How would you call this function?\n",
    "\n",
    "![NVIDIA_Share_0qjev1S9tB.png](attachment:1d3ceeb3-5313-423c-88c7-6b83013d0b8d.png)\n",
    "![image.png](attachment:cd7d22f3-3988-4fe5-8a74-eb8b88d3a8b9.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "2cd65d76-bece-4f59-8c99-8fdb14ac4078",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Answer will not be show given the current configuration\n"
     ]
    }
   ],
   "source": [
    "show_current_answer = True\n",
    "current_question = 3\n",
    "\n",
    "show_answers(show_current_answer, current_question)\n",
    "\n",
    "if(show_current_answer_validated):\n",
    "    print(current_answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4071e10-f9cf-4e61-80e1-7cc3210bc386",
   "metadata": {},
   "source": [
    "#### Part 3, Try Catch\n",
    "\n",
    "```csharp\n",
    "// -----------------------------------------------------------------------\n",
    "// <copyright file=\"ServerCreatePickupPatch.cs\" company=\"Undid-Iridium\">\n",
    "// Copyright (c) Undid-Iridium. All rights reserved.\n",
    "// Licensed under the CC BY-SA 3.0 license.\n",
    "// </copyright>\n",
    "// -----------------------------------------------------------------------\n",
    "\n",
    "#pragma warning disable SA1118\n",
    "\n",
    "namespace CleanupUtility.Patches\n",
    "{\n",
    "    /// <summary>\n",
    "    /// Patches <see cref=\"InventoryExtensions.ServerCreatePickup\"/> to add <see cref=\"Pickup\"/>s to the <see cref=\"PickupChecker\"/>.\n",
    "    /// </summary>\n",
    "    [HarmonyPatch(typeof(InventoryExtensions), nameof(InventoryExtensions.ServerCreatePickup))]\n",
    "    internal static class ServerCreatePickupPatch\n",
    "    {\n",
    "        private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)\n",
    "        {\n",
    "            List<CodeInstruction> newInstructions = ListPool<CodeInstruction>.Shared.Rent(instructions);\n",
    "\n",
    "            LocalBuilder itemZone = generator.DeclareLocal(typeof(ZoneType));\n",
    "\n",
    "            int index = newInstructions.FindIndex(instruction => instruction.opcode == OpCodes.Ldarg_1);\n",
    "\n",
    "            Label skipLabel = generator.DefineLabel();\n",
    "            Label continueProcessing = generator.DefineLabel();\n",
    "            Label skipException = generator.DefineLabel();\n",
    "\n",
    "            LocalBuilder exceptionObject = generator.DeclareLocal(typeof(Exception));\n",
    "\n",
    "            // Our Catch (Try wrapper) block\n",
    "            ExceptionBlock catchBlock = new (ExceptionBlockType.BeginCatchBlock, typeof(Exception));\n",
    "\n",
    "            // Our Exception handling start\n",
    "            ExceptionBlock exceptionStart = new (ExceptionBlockType.BeginExceptionBlock, typeof(Exception));\n",
    "\n",
    "            // Our Exception handling end\n",
    "            ExceptionBlock exceptionEnd = new (ExceptionBlockType.EndExceptionBlock);\n",
    "\n",
    "            newInstructions.InsertRange(index, new[]\n",
    "            {\n",
    "                // Load ItemBase to EStack\n",
    "                new CodeInstruction(OpCodes.Ldarg_0).WithBlocks(exceptionStart).MoveLabelsFrom(newInstructions[index]),\n",
    "\n",
    "                // Assign unspecified enum as the default value, and then try to load the actual value\n",
    "                new CodeInstruction(OpCodes.Ldc_I4_4),\n",
    "\n",
    "                // Then save the player zone to a local variable (This is all done early because spawn deletes information and made it default to surface)\n",
    "                new CodeInstruction(OpCodes.Stloc, itemZone.LocalIndex),\n",
    "\n",
    "                // Load EStack to callvirt and get owner back on Estack\n",
    "                new CodeInstruction(OpCodes.Callvirt, PropertyGetter(typeof(Inventory), nameof(Inventory.gameObject))),\n",
    "\n",
    "                new CodeInstruction(OpCodes.Call, Method(typeof(ReferenceHub), nameof(ReferenceHub.GetHub), new[] { typeof(UnityEngine.GameObject) })),\n",
    "\n",
    "                // Duplicate ItemBase.Owner (if null then two nulls)\n",
    "                new CodeInstruction(OpCodes.Dup),\n",
    "\n",
    "                // If previous owner is null, escape this, still have one null on stack if that is the case\n",
    "                new CodeInstruction(OpCodes.Brfalse_S, skipLabel),\n",
    "\n",
    "                // Using Owner call Player.Get static method with it (Reference hub) and get a Player back, OK game object could be null\n",
    "                new CodeInstruction(OpCodes.Call, Method(typeof(Player), nameof(Player.Get), new[] { typeof(ReferenceHub) })),\n",
    "\n",
    "                // Then get the player Zone (This was probably null)\n",
    "                new CodeInstruction(OpCodes.Callvirt, PropertyGetter(typeof(Player), nameof(Player.Zone))),\n",
    "\n",
    "                // Continue without calling broken escape route\n",
    "                new CodeInstruction(OpCodes.Br_S, continueProcessing),\n",
    "\n",
    "                // Remove current null from stack. Default value setting ZoneType to unspecified if previous owner is null by escaping to this label\n",
    "                new CodeInstruction(OpCodes.Pop).WithLabels(skipLabel),\n",
    "\n",
    "                // Then save the player zone to a local variable (This is all done early because spawn deletes information and made it default to surface)\n",
    "                new CodeInstruction(OpCodes.Stloc, itemZone.LocalIndex).WithLabels(continueProcessing),\n",
    "\n",
    "                // Correctly esacpes try-catch block.\n",
    "                new CodeInstruction(OpCodes.Leave_S, skipException),\n",
    "\n",
    "                // Load the exception from stack\n",
    "                new CodeInstruction(OpCodes.Nop, exceptionObject.LocalIndex).WithBlocks(catchBlock).WithBlocks(exceptionEnd),\n",
    "\n",
    "                // Allows original logic to run.\n",
    "                new CodeInstruction(OpCodes.Nop).WithLabels(skipException),\n",
    "            });\n",
    "\n",
    "            index = newInstructions.FindLastIndex(instruction => instruction.opcode == OpCodes.Ldloc_0);\n",
    "            newInstructions.InsertRange(index, new[]\n",
    "            {\n",
    "                // Calls static instance\n",
    "                new CodeInstruction(OpCodes.Call, PropertyGetter(typeof(Plugin), nameof(Plugin.Instance))),\n",
    "\n",
    "                // Since the instance is now on the stack, we will call ProperttyGetter to get to PickupChecker object from our Instance object\n",
    "                new CodeInstruction(OpCodes.Callvirt, PropertyGetter(typeof(Plugin), nameof(Plugin.PickupChecker))),\n",
    "\n",
    "                /*\n",
    "                 *      .maxstack 4\n",
    "                        .locals init (\n",
    "                            [0] class InventorySystem.Items.Pickups.ItemPickupBase,\n",
    "                            [1] valuetype InventorySystem.Items.Pickups.PickupSyncInfo\n",
    "                        )\n",
    "                */\n",
    "\n",
    "                // Load the variable unto Eval Stack [ItemPickupBase]\n",
    "                new CodeInstruction(OpCodes.Ldloc_0),\n",
    "\n",
    "                // Calls pickup method using local variable 0 (Which is on Eval Stack [ItemPickupBase]) and it gets back a Pickup object onto the EStack [Pickup]\n",
    "                new CodeInstruction(OpCodes.Call, Method(typeof(Pickup), nameof(Pickup.Get))),\n",
    "\n",
    "                // Calls arguemnt 1 from function call unto EStack (Zone)\n",
    "                new CodeInstruction(OpCodes.Ldloc, itemZone.LocalIndex),\n",
    "\n",
    "                // EStack variable used, [PickupChecker (Callvirt arg 0 (Instance)), Pickup (Arg 1 (Param))]\n",
    "                new CodeInstruction(OpCodes.Callvirt, Method(typeof(PickupChecker), nameof(PickupChecker.Add), new[] { typeof(Pickup), typeof(ZoneType) })),\n",
    "            });\n",
    "\n",
    "            for (int z = 0; z < newInstructions.Count; z++)\n",
    "            {\n",
    "                yield return newInstructions[z];\n",
    "            }\n",
    "\n",
    "            ListPool<CodeInstruction>.Shared.Return(newInstructions);\n",
    "        }\n",
    "    }\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14ae1af1-1caf-4ab9-abfd-f147cb5c8c90",
   "metadata": {},
   "source": [
    "#### Part 4, Generics.\n",
    "\n",
    " Type severHand = typeof(PlayerEffectsController);\n",
    "            //MethodInfo[] methods = severHand.GetMethods(BindingFlags.Static | BindingFlags.Public);\n",
    "            //MethodInfo genericMethod = methods.Where(m => m.IsGenericMethod).First(m => m.Name.Equals(\"EnableEffect\"));\n",
    "            MethodInfo[] genericMethod = severHand.GetMethods().Where(m => m.IsGenericMethod && m.Name.Equals(\"EnableEffect\")).ToArray();\n",
    "\n",
    "            foreach (MethodInfo method in genericMethod)\n",
    "            {\n",
    "                Log.Info($\"What is the method info {method}\");\n",
    "            }\n",
    "\n",
    "            var myMethod = severHand\n",
    "                         .GetMethods()\n",
    "                         .Where(m => m.Name == \"EnableEffect\")\n",
    "                         .Select(m => new\n",
    "                         {\n",
    "                             Method = m,\n",
    "                             Params = m.GetParameters(),\n",
    "                         })\n",
    "                         .Where(x => x.Params.Length == 2)\n",
    "                         .Select(x => x.Method)\n",
    "                         .First();\n",
    "            Log.Info($\"What is the method info {myMethod}\");\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b572642-cf58-4daf-a7f3-445779768209",
   "metadata": {},
   "source": [
    "https://harmony.pardeike.net/articles/patching-transpiler.html\n",
    "\n",
    "https://www.kenneth-truyers.net/2016/05/12/yield-return-in-c/\n",
    "\n",
    "https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.ilgenerator.emit?view=net-6.0#system-reflection-emit-ilgenerator-emit(system-reflection-emit-opcode-system-reflection-emit-label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "104c4659-147e-4be0-92fc-df0d3359fb83",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6dcb817d-f24e-431b-9d0a-e38965245e3c",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}