using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("MUCK-Archipelago")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("Muck for Archipelago")]
[assembly: AssemblyTitle("MUCK-Archipelago")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[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 ARCHIPELAGO
{
public static class Constants
{
public static string GivenItemDescription = "This item was provided to you by Archipelago Inc.™";
public static string[] weapons = new string[10] { "Gold Sword", "Steel Sword", "Mithril Sword", "Adamantite Sword", "Obamium Sword", "Wyvern Dagger", "Gronks Sword", "Chunky Hammer", "Night Blade", "Chiefs Spear" };
public static string[] bows = new string[5] { "Wood Bow", "Birch bow", "Fir bow", "Oak Bow", "Ancient Bow" };
public static string[] axes = new string[4] { "Wood Axe", "Steel Axe", "Mithril Axe", "Adamantite Axe" };
public static string[] pickaxes = new string[4] { "Wood Pickaxe", "Steel Pickaxe", "Mithril Pickaxe", "Adamantite Pickaxe" };
public static string[] helmets = new string[5] { "Gold Helmet", "Steel Helmet", "Mithril Helmet", "Adamantite Helmet", "Obamium Helmet" };
public static string[] chestplates = new string[5] { "Gold Chestplate", "Steel Chestplate", "Mithril Chestplate", "Adamantite Chestplate", "Obamium Chestplate" };
public static string[] leggings = new string[5] { "Gold Pants", "Steel Pants", "Mithril Pants", "Adamantite Pants", "Obamium Pants" };
public static string[] boots = new string[5] { "Gold Boots", "Steel Boots", "Mithril Boots", "Adamantite Boots", "Obamium Boots" };
public static List<string> itemsToPrevent => new List<string>
{
"Adamantite Pickaxe", "Gold Pickaxe", "Mithril Pickaxe", "Steel Pickaxe", "Wood Pickaxe", "Oak Bow", "Wood Bow", "Birch bow", "Fir bow", "Ancient Bow",
"Adamantite Axe", "Gold Axe", "Mithril Axe", "Steel Axe", "Wood Axe", "Adamantite Boots", "_ Boots", "Gold Boots", "Mithril Boots", "Obamium Boots",
"Steel Boots", "Wolfskin Boots", "Adamantite Helmet", "Chunkium Helmet", "Gold Helmet", "Mithril Helmet", "Obamium Helmet", "Steel Helmet", "Wolfskin Helmet", "Adamantite Pants",
"Chunkium Pants", "Gold Pants", "Mithril Pants", "Obamium Pants", "Steel Pants", "Wolfskin Pants", "Adamantite Chestplate", "Chunkium Chestplate", "Gold Chestplate", "Mithril Chestplate",
"Obamium Chestplate", "Steel Chestplate", "Wolfskin Chestplate", "Adamantite Sword", "Gold Sword", "Mithril Sword", "Obamium Sword", "Steel Sword", "Chiefs Spear", "Chunky Hammer",
"Gronks Sword", "Night Blade", "Wyvern Dagger"
};
}
[HarmonyPatch(typeof(PowerupInventory))]
[HarmonyPatch("AddPowerup")]
internal class PatcherAddPowerup
{
private static bool Prefix(string name, int powerupId, int objectId)
{
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_0076: Invalid comparison between Unknown and I4
//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
//IL_00c8: Invalid comparison between Unknown and I4
//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
//IL_00fa: Invalid comparison between Unknown and I4
//IL_0126: Unknown result type (might be due to invalid IL or missing references)
//IL_012c: Invalid comparison between Unknown and I4
Vector3 position = ItemManager.Instance.list[objectId].transform.position;
ParticleSystem component = Object.Instantiate<GameObject>(PowerupInventory.Instance.powerupFx, position, Quaternion.identity).GetComponent<ParticleSystem>();
MainModule main = component.main;
((MainModule)(ref main)).startColor = MinMaxGradient.op_Implicit(ItemManager.Instance.allPowerups[powerupId].GetOutlineColor());
if ((int)ItemManager.Instance.allPowerups[powerupId].tier == 2)
{
((Component)component).gameObject.GetComponent<RandomSfx>().sounds = (AudioClip[])(object)new AudioClip[1] { PowerupInventory.Instance.goodPowerupSfx };
((Component)component).GetComponent<RandomSfx>().Randomize(0f);
}
if ((int)ItemManager.Instance.allPowerups[powerupId].tier == 0)
{
Plugin.Instance.sendLocation("PowerupWhite");
}
else if ((int)ItemManager.Instance.allPowerups[powerupId].tier == 1)
{
Plugin.Instance.sendLocation("PowerupBlue");
}
else if ((int)ItemManager.Instance.allPowerups[powerupId].tier == 2)
{
Plugin.Instance.sendLocation("PowerupOrange");
}
return false;
}
}
[HarmonyPatch(typeof(ServerSend))]
[HarmonyPatch("GameOver")]
internal class PatcherGameOver
{
private static bool Prefix(int winnerId = -2)
{
if (winnerId == -3)
{
Plugin.Instance.win();
}
if (winnerId == -2)
{
if (Plugin.Instance.deathlinked)
{
Plugin.Instance.deathlinked = false;
}
else
{
File.WriteAllText("send.deathlink", "u ded lol");
}
}
return true;
}
}
[HarmonyPatch(typeof(InventoryUI))]
[HarmonyPatch("CraftItem")]
internal class PatcherCaftItem
{
private static bool Prefix(InventoryItem item)
{
if (Constants.itemsToPrevent.Contains(item.name))
{
if (!InventoryUI.Instance.IsCraftable(item) || ((Object)(object)InventoryUI.Instance.currentMouseItem != (Object)null && (!item.Compare(InventoryUI.Instance.currentMouseItem) || InventoryUI.Instance.currentMouseItem.amount + item.craftAmount > InventoryUI.Instance.currentMouseItem.max)) || Plugin.Instance.hasLocation(item.name))
{
return false;
}
CraftRequirement[] requirements = item.requirements;
CraftRequirement[] array = requirements;
foreach (CraftRequirement val in array)
{
int num = 0;
foreach (InventoryCell cell in InventoryUI.Instance.cells)
{
if (!((Object)(object)cell.currentItem == (Object)null) && cell.currentItem.Compare(val.item))
{
if (cell.currentItem.amount > val.amount)
{
int num2 = val.amount - num;
InventoryItem currentItem = cell.currentItem;
currentItem.amount -= num2;
cell.UpdateCell();
break;
}
num += cell.currentItem.amount;
cell.RemoveItem();
}
}
Plugin.Instance.sendUniqueLocation(item.name);
}
return false;
}
return true;
}
}
[HarmonyPatch(typeof(InventoryUI))]
[HarmonyPatch("PickupItem")]
internal class PatcherPickupItem
{
private static bool Prefix(InventoryItem item)
{
if (Constants.itemsToPrevent.Contains(item.name) && item.description != Constants.GivenItemDescription)
{
Plugin.Instance.sendALternateUniqueLocation(item.name);
return false;
}
return true;
}
}
[HarmonyPatch(typeof(InventoryUI))]
[HarmonyPatch("AddItemToInventory")]
internal class PatcherAddItemToInventory
{
private static bool Prefix(InventoryItem item)
{
if (Constants.itemsToPrevent.Contains(item.name) && item.description != Constants.GivenItemDescription)
{
Plugin.Instance.sendALternateUniqueLocation(item.name);
return false;
}
return true;
}
}
[HarmonyPatch(typeof(GameManager))]
[HarmonyPatch("StartGame")]
internal class PatcherStartGame
{
private static void Postfix()
{
Plugin.Instance.atGameStart();
}
}
[BepInPlugin("MUCK-Archipelago", "Muck for Archipelago", "1.0.0")]
public class Plugin : BaseUnityPlugin
{
public static ManualLogSource Logger;
public static Plugin Instance;
public Dictionary<string, int> givenPowerups;
public Dictionary<string, int> givenTools;
public Harmony harmony = new Harmony("MUCK-Archipelago");
public bool hasReceivedArrows;
public bool deathlinked;
private async void Awake()
{
Logger = ((BaseUnityPlugin)this).Logger;
Logger.LogInfo((object)"Plugin MUCK-Archipelago is loaded!");
Logger.LogInfo((object)"It's muckin' time");
harmony.PatchAll();
Instance = this;
deathlinked = false;
resetGivenPowerups();
resetGivenTools();
}
public void Update()
{
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: Invalid comparison between Unknown and I4
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Invalid comparison between Unknown and I4
if (File.Exists("receive.deathlink"))
{
if ((int)GameManager.state == 1)
{
deathlinked = true;
PlayerStatus.Instance.Damage(0, 0, true);
}
File.Delete("receive.deathlink");
}
if ((int)GameManager.state == 1)
{
try
{
updateGivenPowerups(getPowerupsDict());
updateGivenTools(getToolsDict());
}
catch
{
}
}
}
public async void atGameStart()
{
if (File.Exists("ARCHIPELAGO_Powerups.itmlst"))
{
File.Delete("ARCHIPELAGO_Powerups.itmlst");
}
if (File.Exists("ARCHIPELAGO_Locations.lctlst"))
{
File.Delete("ARCHIPELAGO_Locations.lctlst");
}
if (File.Exists("ARCHIPELAGO_Options.optlst"))
{
File.Delete("ARCHIPELAGO_Options.optlst");
}
if (File.Exists("ARCHIPELAGO_Tools.itmlst"))
{
File.Delete("ARCHIPELAGO_Tools.itmlst");
}
if (File.Exists("victory"))
{
File.Delete("victory");
Logger.LogInfo((object)"Destroying victory");
}
Logger.LogInfo((object)"ARCHIPELAGO_Powerups.itmlst");
File.WriteAllText("ARCHIPELAGO_Powerups.itmlst", "Broccoli,0\r\nDumbbell,0\r\nJetpack,0\r\nOrange Juice,0\r\nPeanut Butter,0\r\nBlue Pill,0\r\nRed Pill,0\r\nSneaker,0\r\nRobin Hood Hat,0\r\nSpooo Bean,0\r\nBulldozer,0\r\nHorseshoe,0\r\nDanis Milk,0\r\nPiggybank,0\r\nCrimson Dagger,0\r\nDracula,0\r\nJanniks Frog,0\r\nJuice,0\r\nAdrenaline,0\r\nBerserk,0\r\nCheckered Shirt,0\r\nSniper Scope,0\r\nKnuts Hammer,0\r\nWings of Glory,0\r\nEnforcer,0");
Logger.LogInfo((object)"Creatinng ARCHIPELAGO_Locations.lctlst");
File.WriteAllText("ARCHIPELAGO_Locations.lctlst", "PowerupWhite,0\r\nPowerupBlue,0\r\nPowerupOrange,0\r\nAdamantite Pickaxe,0\r\nGold Pickaxe,0\r\nMithril Pickaxe,0\r\nSteel Pickaxe,0\r\nWood Pickaxe,0\r\nOak Bow,0\r\nWood Bow,0\r\nBirch bow,0\r\nFir bow,0\r\nAncient Bow,0\r\nAdamantite Axe,0\r\nGold Axe,0\r\nMithril Axe,0\r\nSteel Axe,0\r\nWood Axe,0\r\nAdamantite Boots,0\r\n_ Boots,0\r\nGold Boots,0\r\nMithril Boots,0\r\nObamium Boots,0\r\nSteel Boots,0\r\nWolfskin Boots,0\r\nAdamantite Helmet,0\r\nChunkium Helmet,0\r\nGold Helmet,0\r\nMithril Helmet,0\r\nObamium Helmet,0\r\nSteel Helmet,0\r\nWolfskin Helmet,0\r\nAdamantite Pants,0\r\nChunkium Pants,0\r\nGold Pants,0\r\nMithril Pants,0\r\nObamium Pants,0\r\nSteel Pants,0\r\nWolfskin Pants,0\r\nAdamantite Chestplate,0\r\nChunkium Chestplate,0\r\nGold Chestplate,0\r\nMithril Chestplate,0\r\nObamium Chestplate,0\r\nSteel Chestplate,0\r\nWolfskin Chestplate,0\r\nAdamantite Sword,0\r\nGold Sword,0\r\nMithril Sword,0\r\nObamium Sword,0\r\nSteel Sword,0\r\nChiefs Spear,0\r\nChunky Hammer,0\r\nGronks Sword,0\r\nNight Blade,0\r\nWyvern Dagger,0");
Logger.LogInfo((object)"ARCHIPELAGO_Options.optlst");
File.WriteAllText("ARCHIPELAGO_Options.optlst", "allowLootAsLocations,0");
Logger.LogInfo((object)"ARCHIPELAGO_Tools.itmlst");
File.WriteAllText("ARCHIPELAGO_Tools.itmlst", "weapons,0\r\nbows,0\r\naxes,0\r\npickaxes,0\r\nhelmets,0\r\nchestplates,0\r\nleggings,0\r\nboots,0");
await Task.Delay(3000);
resetGivenPowerups();
updateGivenPowerups(getPowerupsDict());
resetGivenTools();
updateGivenTools(getToolsDict());
fullyHeal();
}
public void forceGivePowerup(int powerupId, int count)
{
FieldInfo field = ((object)PowerupInventory.Instance).GetType().GetField("powerups", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
int[] array = (int[])field.GetValue(PowerupInventory.Instance);
array[powerupId] += count;
field.SetValue(PowerupInventory.Instance, array);
UiEvents.Instance.AddPowerup(ItemManager.Instance.allPowerups[powerupId]);
for (int i = 0; i < count; i++)
{
PowerupUI.Instance.AddPowerup(powerupId);
}
}
public bool giveRightTool(string name, int count)
{
string[] array;
switch (name)
{
case "weapons":
array = Constants.weapons;
break;
case "bows":
array = Constants.bows;
break;
case "axes":
array = Constants.axes;
break;
case "pickaxes":
array = Constants.pickaxes;
break;
case "helmets":
array = Constants.helmets;
break;
case "chestplates":
array = Constants.chestplates;
break;
case "leggings":
array = Constants.leggings;
break;
case "boots":
array = Constants.boots;
break;
default:
return false;
}
deleteAllItemsFromList(array);
return giveUniqueItem(array[count - 1], 1);
}
public void deleteAllItemsFromList(string[] list)
{
int num = 0;
foreach (string text in list)
{
InventoryItem[] allScriptableItems = ItemManager.Instance.allScriptableItems;
foreach (InventoryItem val in allScriptableItems)
{
if (val.name == text)
{
num = val.id;
break;
}
}
InventoryUI.Instance.RemoveItem(ItemManager.Instance.allScriptableItems[num]);
}
}
public bool isGamePlaying()
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Invalid comparison between Unknown and I4
return (int)GameManager.state == 1;
}
public bool isPlayerDead()
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Invalid comparison between Unknown and I4
return (int)GameManager.state == 2;
}
public void printPowerupList()
{
foreach (KeyValuePair<string, int> item in ItemManager.Instance.stringToPowerupId)
{
Logger.LogInfo((object)$"name : {item.Key}, id : {item.Value}");
}
}
public Dictionary<string, int> getPowerupsDict()
{
string str = File.ReadAllText("ARCHIPELAGO_Powerups.itmlst");
return strToDict(str);
}
public Dictionary<string, int> getToolsDict()
{
string str = File.ReadAllText("ARCHIPELAGO_Tools.itmlst");
return strToDict(str);
}
public void resetGivenPowerups()
{
Logger.LogInfo((object)"Powerup Dict Reset");
givenPowerups = new Dictionary<string, int>
{
{ "Broccoli", 0 },
{ "Dumbbell", 0 },
{ "Jetpack", 0 },
{ "Orange Juice", 0 },
{ "Peanut Butter", 0 },
{ "Blue Pill", 0 },
{ "Red Pill", 0 },
{ "Sneaker", 0 },
{ "Robin Hood Hat", 0 },
{ "Spooo Bean", 0 },
{ "Bulldozer", 0 },
{ "Horseshoe", 0 },
{ "Danis Milk", 0 },
{ "Piggybank", 0 },
{ "Crimson Dagger", 0 },
{ "Dracula", 0 },
{ "Janniks Frog", 0 },
{ "Juice", 0 },
{ "Adrenaline", 0 },
{ "Berserk", 0 },
{ "Checkered Shirt", 0 },
{ "Sniper Scope", 0 },
{ "Knuts Hammer", 0 },
{ "Wings of Glory", 0 },
{ "Enforcer", 0 }
};
}
public void resetGivenTools()
{
Logger.LogInfo((object)"Tools Dict Reset");
givenTools = new Dictionary<string, int>
{
{ "weapons", 0 },
{ "bows", 0 },
{ "axes", 0 },
{ "pickaxes", 0 },
{ "helmets", 0 },
{ "chestplates", 0 },
{ "leggings", 0 },
{ "boots", 0 }
};
hasReceivedArrows = false;
}
public void sendLocation(string locationName)
{
Dictionary<string, int> dictionary = strToDict(File.ReadAllText("ARCHIPELAGO_Locations.lctlst"));
dictionary[locationName]++;
Logger.LogInfo((object)dictToStr(dictionary));
File.WriteAllText("ARCHIPELAGO_Locations.lctlst", dictToStr(dictionary));
}
public void sendUniqueLocation(string locationName)
{
Dictionary<string, int> dictionary = strToDict(File.ReadAllText("ARCHIPELAGO_Locations.lctlst"));
Logger.LogInfo((object)locationName);
if (dictionary[locationName] == 0)
{
sendLocation(locationName);
}
}
public void sendALternateUniqueLocation(string locationName)
{
if (allowAlternateLocations())
{
sendUniqueLocation(locationName);
}
}
public bool hasLocation(string locationName)
{
Dictionary<string, int> dictionary = strToDict(File.ReadAllText("ARCHIPELAGO_Locations.lctlst"));
if (dictionary[locationName] > 0)
{
return true;
}
return false;
}
public static Dictionary<string, int> strToDict(string str)
{
string[] array = str.Split(new string[2]
{
Environment.NewLine,
"\n"
}, StringSplitOptions.None);
Dictionary<string, int> dictionary = new Dictionary<string, int>();
string[] array2 = array;
foreach (string text in array2)
{
string[] array3 = text.Split(",".ToCharArray());
dictionary.Add(array3[0], int.Parse(array3[1]));
}
return dictionary;
}
public static string dictToStr(Dictionary<string, int> dict)
{
string text = "";
bool flag = true;
foreach (KeyValuePair<string, int> item in dict)
{
if (flag)
{
text += $"{item.Key},{item.Value}";
flag = false;
}
else
{
text += $"\n{item.Key},{item.Value}";
}
}
return text;
}
public void updateGivenPowerups(Dictionary<string, int> powerupsToHave)
{
foreach (KeyValuePair<string, int> item in powerupsToHave)
{
if (item.Value > givenPowerups[item.Key])
{
int num = item.Value - givenPowerups[item.Key];
Logger.LogInfo((object)(item.Key + " : " + num));
forceGivePowerup(ItemManager.Instance.stringToPowerupId[item.Key], num);
givenPowerups[item.Key] += num;
PlayerStatus.Instance.UpdateStats();
}
}
}
public void updateGivenTools(Dictionary<string, int> toolsToHave)
{
foreach (KeyValuePair<string, int> item in toolsToHave)
{
if (item.Value > givenTools[item.Key] && giveRightTool(item.Key, item.Value))
{
givenTools[item.Key] += item.Value - givenTools[item.Key];
}
}
if (givenTools["bows"] > 0 && !hasReceivedArrows)
{
giveUniqueItem("Flint Arrow", 500 * givenTools["bows"]);
hasReceivedArrows = true;
}
}
public bool allowAlternateLocations()
{
return strToDict(File.ReadAllText("ARCHIPELAGO_Options.optlst"))["allowLootAsLocations"] == 1;
}
public void win()
{
File.WriteAllText("victory", "Bob defeated");
}
public void fullyHeal()
{
PlayerStatus.Instance.hp = PlayerStatus.Instance.maxHp;
}
public bool giveUniqueItem(string itemName, int count)
{
InventoryItem val = ScriptableObject.CreateInstance<InventoryItem>();
InventoryItem[] allScriptableItems = ItemManager.Instance.allScriptableItems;
foreach (InventoryItem val2 in allScriptableItems)
{
if (val2.name == itemName)
{
val.Copy(val2, count);
val.description = Constants.GivenItemDescription;
break;
}
}
if (InventoryUI.Instance.AddItemToInventory(val) == 1)
{
return false;
}
return true;
}
public void godMode()
{
giveUniqueItem("AncientCore", 1);
giveUniqueItem("Obamium Boots", 1);
giveUniqueItem("Obamium Helmet", 1);
giveUniqueItem("Obamium Pants", 1);
giveUniqueItem("Obamium Chestplate", 1);
giveUniqueItem("Chiefs Spear", 1);
giveUniqueItem("Meat Soup", 69);
giveUniqueItem("Adamantite bar", 69);
giveUniqueItem("Gold bar", 69);
giveUniqueItem("Iron bar", 150);
giveUniqueItem("Mithril bar", 69);
giveUniqueItem("Obamium bar", 69);
giveUniqueItem("Ruby", 69);
giveUniqueItem("Birch Wood", 69);
giveUniqueItem("Rock", 150);
giveUniqueItem("Dark Oak Wood", 69);
giveUniqueItem("Oak Wood", 69);
giveUniqueItem("Fir Wood", 69);
giveUniqueItem("Wood", 300);
giveUniqueItem("Blue Gem", 69);
giveUniqueItem("Green Gem", 69);
giveUniqueItem("Pink Gem", 69);
giveUniqueItem("Red Gem", 69);
giveUniqueItem("Yellow Gem", 69);
giveUniqueItem("Flax Fibers", 69);
giveUniqueItem("Rope", 69);
giveUniqueItem("Wheat", 69);
giveUniqueItem("Raw Meat", 69);
givenPowerups = new Dictionary<string, int>
{
{ "Broccoli", -100 },
{ "Dumbbell", -10000 },
{ "Jetpack", -5 },
{ "Orange Juice", -100 },
{ "Peanut Butter", -100 },
{ "Blue Pill", -100 },
{ "Red Pill", -100 },
{ "Sneaker", -100 },
{ "Robin Hood Hat", -100 },
{ "Spooo Bean", -100 },
{ "Bulldozer", -100 },
{ "Horseshoe", -100 },
{ "Danis Milk", -100 },
{ "Piggybank", -100 },
{ "Crimson Dagger", -100 },
{ "Dracula", -100 },
{ "Janniks Frog", -100 },
{ "Juice", -100 },
{ "Adrenaline", -100 },
{ "Berserk", -100 },
{ "Checkered Shirt", -100 },
{ "Sniper Scope", -100 },
{ "Knuts Hammer", -100 },
{ "Wings of Glory", -100 },
{ "Enforcer", -100 }
};
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "MUCK-Archipelago";
public const string PLUGIN_NAME = "Muck for Archipelago";
public const string PLUGIN_VERSION = "1.0.0";
}
}
