using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Logging;
using CozyFurniture.NetcodePatcher;
using GameNetcodeStuff;
using HarmonyLib;
using LethalLib.Modules;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
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.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("CozyFurniture")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("A furniture for Lethal Company")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("CozyFurniture")]
[assembly: AssemblyTitle("CozyFurniture")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
internal class <Module>
{
static <Module>()
{
}
}
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace CozyFurniture
{
[Serializable]
[HarmonyPatch]
public class ConfigSync
{
public static bool isSynced;
public static ConfigSync defaultConfig;
public static ConfigSync instance;
public bool syncUnlockEverything;
public bool syncShareEverything;
public bool syncSyncUnsharedEmotes;
public bool syncEnableMovingWhileEmoting;
public bool syncDisableRaritySystem;
public int syncStartingEmoteCredits;
public float syncAddEmoteCreditsMultiplier;
public bool syncPurchaseEmotesWithDefaultCurrency;
public float syncPriceMultiplierEmotesStore;
public int syncBasePriceEmoteTier0;
public int syncBasePriceEmoteTier1;
public int syncBasePriceEmoteTier2;
public int syncBasePriceEmoteTier3;
public int syncNumEmotesStoreRotation;
public float syncRotationChanceEmoteTier0;
public float syncRotationChanceEmoteTier1;
public float syncRotationChanceEmoteTier2;
public float syncRotationChanceEmoteTier3;
public bool syncEnableMaskedEnemiesEmoting;
public float syncMaskedEnemiesEmoteChanceOnEncounter;
public bool syncMaskedEnemiesAlwaysEmoteOnFirstEncounter;
public bool syncOverrideStopAndStareDuration;
public float syncMaskedEnemyEmoteRandomDelayMin;
public float syncMaskedEnemyEmoteRandomDelayMax;
public float syncMaskedEnemyEmoteRandomDurationMin;
public float syncMaskedEnemyEmoteRandomDurationMax;
public static Vector2 syncMaskedEnemyEmoteRandomDelay;
public static Vector2 syncMaskedEnemyEmoteRandomDuration;
public static HashSet<ulong> syncedClients;
public ConfigSync()
{
if (syncUnlockEverything)
{
syncShareEverything = true;
}
}
public Vector2 ParseVector2FromString(string str)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Unknown result type (might be due to invalid IL or missing references)
//IL_0076: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
Vector2 result = Vector2.zero;
try
{
string[] array = str.Split(',');
if (float.TryParse(array[0].Trim(' '), out var result2) && float.TryParse(array[1].Trim(' '), out var result3))
{
result = new Vector2(Mathf.Min(Mathf.Abs(result2), Mathf.Abs(result3)), Mathf.Max(Mathf.Abs(result2), Mathf.Abs(result3)));
}
return result;
}
catch
{
}
return Vector2.zero;
}
public static void BuildDefaultConfigSync()
{
defaultConfig = new ConfigSync();
instance = new ConfigSync();
}
[HarmonyPatch(typeof(StartOfRound), "Awake")]
[HarmonyPostfix]
public static void ResetValues()
{
isSynced = false;
}
private static void OnRequestConfigSyncClientRpc(ulong clientId, FastBufferReader reader)
{
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
if (!NetworkManager.Singleton.IsClient)
{
return;
}
int num = default(int);
((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
if (((FastBufferReader)(ref reader)).TryBeginRead(num))
{
byte[] data = new byte[num];
((FastBufferReader)(ref reader)).ReadBytesSafe(ref data, num, 0);
instance = DeserializeFromByteArray(data);
if (instance.syncUnlockEverything)
{
instance.syncShareEverything = true;
}
syncMaskedEnemyEmoteRandomDelay = new Vector2(instance.syncMaskedEnemyEmoteRandomDelayMin, instance.syncMaskedEnemyEmoteRandomDelayMax);
syncMaskedEnemyEmoteRandomDuration = new Vector2(instance.syncMaskedEnemyEmoteRandomDurationMin, instance.syncMaskedEnemyEmoteRandomDurationMax);
isSynced = true;
}
}
public static byte[] SerializeConfigToByteArray(ConfigSync config)
{
BinaryFormatter binaryFormatter = new BinaryFormatter();
MemoryStream memoryStream = new MemoryStream();
binaryFormatter.Serialize(memoryStream, config);
return memoryStream.ToArray();
}
public static ConfigSync DeserializeFromByteArray(byte[] data)
{
MemoryStream serializationStream = new MemoryStream(data);
BinaryFormatter binaryFormatter = new BinaryFormatter();
return (ConfigSync)binaryFormatter.Deserialize(serializationStream);
}
}
public class NetworkHandler : NetworkBehaviour
{
public static NetworkHandler Instance { get; private set; }
public static event Action<string> LevelEvent;
public override void OnNetworkSpawn()
{
NetworkHandler.LevelEvent = null;
if (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer)
{
NetworkHandler instance = Instance;
if (instance != null)
{
((Component)instance).gameObject.GetComponent<NetworkObject>().Despawn(true);
}
}
Instance = this;
((NetworkBehaviour)this).OnNetworkSpawn();
}
[ClientRpc]
public void EventClientRpc(string eventName)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Invalid comparison between Unknown and I4
//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
//IL_00d4: Invalid comparison between Unknown and I4
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_0088: Unknown result type (might be due to invalid IL or missing references)
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
if (networkManager == null || !networkManager.IsListening)
{
return;
}
if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
{
ClientRpcParams val = default(ClientRpcParams);
FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(506852059u, val, (RpcDelivery)0);
bool flag = eventName != null;
((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
if (flag)
{
((FastBufferWriter)(ref val2)).WriteValueSafe(eventName, false);
}
((NetworkBehaviour)this).__endSendClientRpc(ref val2, 506852059u, val, (RpcDelivery)0);
}
if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
{
NetworkHandler.LevelEvent?.Invoke(eventName);
}
}
protected override void __initializeVariables()
{
((NetworkBehaviour)this).__initializeVariables();
}
[RuntimeInitializeOnLoadMethod]
internal static void InitializeRPCS_NetworkHandler()
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
NetworkManager.__rpc_func_table.Add(506852059u, new RpcReceiveHandler(__rpc_handler_506852059));
}
private static void __rpc_handler_506852059(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
NetworkManager networkManager = target.NetworkManager;
if (networkManager != null && networkManager.IsListening)
{
bool flag = default(bool);
((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
string eventName = null;
if (flag)
{
((FastBufferReader)(ref reader)).ReadValueSafe(ref eventName, false);
}
target.__rpc_exec_stage = (__RpcExecStage)2;
((NetworkHandler)(object)target).EventClientRpc(eventName);
target.__rpc_exec_stage = (__RpcExecStage)0;
}
}
protected internal override string __getTypeName()
{
return "NetworkHandler";
}
}
[HarmonyPatch]
public class NetworkObjectManager
{
private static GameObject networkPrefab;
[HarmonyPostfix]
[HarmonyPatch(typeof(GameNetworkManager), "Start")]
public static void Init()
{
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Expected O, but got Unknown
if (!((Object)(object)networkPrefab != (Object)null))
{
networkPrefab = (GameObject)Plugin.networkBundle.LoadAsset("ExampleNetworkHandler");
networkPrefab.AddComponent<NetworkHandler>();
NetworkManager.Singleton.AddNetworkPrefab(networkPrefab);
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(StartOfRound), "Awake")]
private static void SpawnNetworkHandler()
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
if (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer)
{
GameObject val = Object.Instantiate<GameObject>(networkPrefab, Vector3.zero, Quaternion.identity);
val.GetComponent<NetworkObject>().Spawn(false);
}
}
}
[BepInPlugin("CozyFurniture", "CozyFurniture", "1.0.0")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class Plugin : BaseUnityPlugin
{
private static Plugin instance;
public static AssetBundle bundle;
public static AssetBundle networkBundle;
public static GameObject shipObject;
private readonly Harmony harmony = new Harmony("CozyFurniture");
internal ManualLogSource mls;
private void Awake()
{
NetcodePatcher();
string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
bundle = AssetBundle.LoadFromFile(Path.Combine(directoryName, "ship"));
shipObject = bundle.LoadAsset<GameObject>("Assets/ShipInside (1).prefab");
NetworkPrefabs.RegisterNetworkPrefab(shipObject);
Utilities.FixMixerGroups(shipObject);
SpawnNetworkManager();
if ((Object)(object)bundle == (Object)null)
{
mls.LogError((object)"Failed to load custom assets.");
return;
}
if ((Object)(object)instance == (Object)null)
{
instance = this;
}
mls = Logger.CreateLogSource("CozyFurniture");
mls.LogInfo((object)"CozyFurniture initalized");
mls.LogInfo((object)("Mothership Asset: " + (object)bundle));
harmony.PatchAll(typeof(Plugin));
harmony.PatchAll(typeof(TerminalPatch));
harmony.PatchAll(typeof(SpacePatcher));
[ServerRpc]
void SpawnNetworkManager()
{
string directoryName2 = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
string fileName = Path.GetFileName(directoryName2);
networkBundle = AssetBundle.LoadFromFile(fileName);
}
}
private static void NetcodePatcher()
{
Type[] types = Assembly.GetExecutingAssembly().GetTypes();
Type[] array = types;
foreach (Type type in array)
{
MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
MethodInfo[] array2 = methods;
foreach (MethodInfo methodInfo in array2)
{
object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
if (customAttributes.Length != 0)
{
methodInfo.Invoke(null, null);
}
}
}
}
private void Update()
{
}
}
[HarmonyPatch]
public static class SpacePatcher
{
public static ManualLogSource mls;
public static bool inSpace = false;
public static Plugin pluginInstance;
public static GameObject shipInstantiation;
public static AutoParentToShip[] furnitureArray;
public static HashSet<string> blacklistedFurnitureObjects = new HashSet<string>();
public static HashSet<AutoParentToShip> toggledFurniture = new HashSet<AutoParentToShip>();
public static GameObject shipRails;
public static GameObject shipRailsPost;
[HarmonyPatch(typeof(StartOfRound), "TeleportPlayerInShipIfOutOfRoomBounds")]
[HarmonyPrefix]
public static bool TeleportPlayerInShipIfOutOfRoomBounds()
{
if (inSpace)
{
return false;
}
return true;
}
[HarmonyPatch(typeof(StartOfRound), "Awake")]
[HarmonyPostfix]
public static void SpawnShip()
{
}
[HarmonyPatch(typeof(ShipBuildModeManager), "PlayerMeetsConditionsToBuild")]
[HarmonyPostfix]
public static void PlayerMeetsConditionsToBuild(ref bool __result)
{
PlayerControllerB val = Object.FindObjectOfType<PlayerControllerB>();
__result = inSpace;
}
[HarmonyPostfix]
[HarmonyPatch(typeof(RoundManager), "Awake")]
private static void AwakeServerRpc()
{
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
NetworkHandler.LevelEvent += ReceivedEventFromServer;
mls = Logger.CreateLogSource("CozyFurniture");
shipInstantiation = Object.Instantiate<GameObject>(Plugin.shipObject, new Vector3(-13.7527f, 0.96f, -15.52f), Quaternion.identity);
NetworkPrefabs.RegisterNetworkPrefab(shipInstantiation);
toggledFurniture = new HashSet<AutoParentToShip>();
mls.LogInfo((object)"Server side Starting game");
shipRails = GameObject.Find("ShipRails");
shipRailsPost = GameObject.Find("ShipRailPosts");
if ((Object)(object)shipInstantiation != (Object)null)
{
shipInstantiation.transform.Rotate(new Vector3(0f, 1f, 0f), 180f);
shipInstantiation.transform.Rotate(new Vector3(1f, 0f, 0f), 270f);
}
blacklistedFurnitureObjects.Add("FileCabinet");
blacklistedFurnitureObjects.Add("Terminal");
blacklistedFurnitureObjects.Add("Bunkbeds");
blacklistedFurnitureObjects.Add("StorageCloset");
blacklistedFurnitureObjects.Add("Teleporter(Clone)");
blacklistedFurnitureObjects.Add("ShipHorn(Clone)");
blacklistedFurnitureObjects.Add("InverseTeleporter(Clone)");
blacklistedFurnitureObjects.Add("SignalTranslator(Clone)");
GameObject.Find("ShipRails").SetActive(true);
GameObject.Find("ShipRailPosts").SetActive(true);
}
[HarmonyPostfix]
[HarmonyPatch(typeof(RoundManager), "InitializeRandomNumberGenerators")]
private static void SubscribeToHandler()
{
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
NetworkHandler.LevelEvent += ReceivedEventFromServer;
inSpace = false;
shipInstantiation.SetActive(false);
furnitureArray = Object.FindObjectsOfType<AutoParentToShip>();
RoundManager.Instance.playersManager.shipDoorsAnimator.SetBool("Closed", true);
shipRails.SetActive(true);
shipRailsPost.SetActive(true);
BoxCollider component = GameObject.Find("ShipInnerRoomBoundsTrigger").GetComponent<BoxCollider>();
component.center = new Vector3(0f, 0f, 0f);
component.size = new Vector3(1f, 0f, 0.9999999f);
mls.LogInfo((object)"Server side Starting game");
if (furnitureArray == null)
{
return;
}
mls.LogInfo((object)furnitureArray);
mls.LogInfo((object)"Found furniture array");
AutoParentToShip[] array = furnitureArray;
foreach (AutoParentToShip val in array)
{
if (!blacklistedFurnitureObjects.Contains(((Object)((Component)val).gameObject).name))
{
((Component)val).gameObject.SetActive(false);
toggledFurniture.Add(val);
}
}
}
[HarmonyPostfix]
[HarmonyPatch(typeof(RoundManager), "DespawnPropsAtEndOfRound")]
private static void UnsubscribeFromHandler()
{
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
NetworkHandler.LevelEvent -= ReceivedEventFromServer;
inSpace = true;
mls = Logger.CreateLogSource("CozyFurniture");
Object.FindObjectOfType<HangarShipDoor>().SetDoorButtonsEnabled(true);
BoxCollider component = GameObject.Find("ShipInnerRoomBoundsTrigger").GetComponent<BoxCollider>();
component.center = new Vector3(-0.487964f, 0f, 0f);
component.size = new Vector3(1.975929f, 1f, 1f);
furnitureArray = Object.FindObjectsOfType<AutoParentToShip>();
shipInstantiation.SetActive(true);
shipRails.SetActive(false);
shipRailsPost.SetActive(false);
if (toggledFurniture == null || furnitureArray == null)
{
return;
}
mls.LogInfo((object)furnitureArray);
mls.LogInfo((object)"Found furniture array");
foreach (AutoParentToShip item in toggledFurniture.ToList())
{
if (!blacklistedFurnitureObjects.Contains(((Object)((Component)item).gameObject).name))
{
((Component)item).gameObject.SetActive(true);
toggledFurniture.Remove(item);
}
}
}
private static void ReceivedEventFromServer(string eventName)
{
}
private static void SendEventToClients(string eventName)
{
if (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer)
{
NetworkHandler.Instance.EventClientRpc(eventName);
}
}
}
[HarmonyPatch]
public static class TerminalPatch
{
public static ManualLogSource mls;
public static Terminal terminalInstance;
public static int currentFurnitureCredits;
public static Dictionary<string, int> currentFurnitureCreditsByPlayer;
public static List<TerminalNode> ShipFurnitureSelection = new List<TerminalNode>();
public static bool initializedTerminalNodes = false;
private static string confirmFurnitureOpeningText = "You have requested to order a new piece of furniture.";
[HarmonyPatch(typeof(Terminal), "Awake")]
[HarmonyPostfix]
public static void InitializeTerminal(Terminal __instance)
{
terminalInstance = __instance;
currentFurnitureCreditsByPlayer = new Dictionary<string, int>();
if (!initializedTerminalNodes)
{
EditExistingTerminalNodesForFurniture();
}
}
[HarmonyPatch(typeof(Terminal), "RotateShipDecorSelection")]
[HarmonyPrefix]
public static bool HijackDecor()
{
NetworkHandler.LevelEvent += ReceivedEventFromServer;
Random random = new Random(StartOfRound.Instance.randomMapSeed + 65);
terminalInstance.ShipDecorSelection.Clear();
List<TerminalNode> list = new List<TerminalNode>();
List<TerminalNode> list2 = new List<TerminalNode>();
for (int i = 0; i < StartOfRound.Instance.unlockablesList.unlockables.Count; i++)
{
if (StartOfRound.Instance.unlockablesList.unlockables[i].IsPlaceable || (Object)(object)StartOfRound.Instance.unlockablesList.unlockables[i].suitMaterial == (Object)null)
{
if ((Object)(object)StartOfRound.Instance.unlockablesList.unlockables[i].shopSelectionNode != (Object)null && !StartOfRound.Instance.unlockablesList.unlockables[i].alwaysInStock)
{
list2.Add(StartOfRound.Instance.unlockablesList.unlockables[i].shopSelectionNode);
StartOfRound.Instance.unlockablesList.unlockables[i].alwaysInStock = true;
}
}
else if ((Object)(object)StartOfRound.Instance.unlockablesList.unlockables[i].shopSelectionNode != (Object)null && !StartOfRound.Instance.unlockablesList.unlockables[i].alwaysInStock)
{
list.Add(StartOfRound.Instance.unlockablesList.unlockables[i].shopSelectionNode);
}
}
int num = random.Next(4, 6);
for (int j = 0; j < num; j++)
{
if (list.Count <= 0)
{
break;
}
TerminalNode item = list2[random.Next(0, list2.Count)];
ShipFurnitureSelection.Add(item);
list2.Remove(item);
TerminalNode item2 = list[random.Next(0, list.Count)];
terminalInstance.ShipDecorSelection.Add(item2);
list.Remove(item2);
}
return false;
}
private static void ReceivedEventFromServer(string eventName)
{
}
[HarmonyPatch(typeof(Terminal), "LoadNewNodeIfAffordable")]
[HarmonyPostfix]
public static void GenerateFurniture(ref TerminalNode node)
{
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
if (node.shipUnlockableID == -1)
{
return;
}
UnlockableItem val = StartOfRound.Instance.unlockablesList.unlockables[node.shipUnlockableID];
if (StartOfRound.Instance.inShipPhase || StartOfRound.Instance.shipHasLanded)
{
AnimatorStateInfo currentAnimatorStateInfo = StartOfRound.Instance.shipAnimator.GetCurrentAnimatorStateInfo(0);
if (((AnimatorStateInfo)(ref currentAnimatorStateInfo)).tagHash == Animator.StringToHash("ShipIdle"))
{
if (!ShipFurnitureSelection.Contains(node) && !val.alwaysInStock && (!node.buyUnlockable || (Object)(object)val.shopSelectionNode == (Object)null))
{
Debug.Log((object)("Not in stock, node: " + ((Object)node).name));
terminalInstance.LoadNewNode(terminalInstance.terminalNodes.specialNodes[16]);
}
return;
}
}
terminalInstance.LoadNewNode(terminalInstance.terminalNodes.specialNodes[15]);
}
public static void EditExistingTerminalNodesForFurniture()
{
initializedTerminalNodes = true;
foreach (TerminalNode specialNode in terminalInstance.terminalNodes.specialNodes)
{
if (((Object)specialNode).name == "Start")
{
string text = "Type \"Help\" for a list of commands.";
int num = specialNode.displayText.IndexOf(text);
if (num != -1)
{
num += text.Length;
string value = "\n\n[CozyFurniture]\nType \"Furniture\" for a list of commands.";
specialNode.displayText = specialNode.displayText.Insert(num, value);
}
else
{
Debug.LogError((object)"Failed to add furniture tip to terminal. Maybe an update broke it?");
}
}
else if (((Object)specialNode).name == "HelpCommands")
{
string value2 = "[numberOfItemsOnRoute]";
int num2 = specialNode.displayText.IndexOf(value2);
if (num2 != -1)
{
string value3 = ">FURNITURE\nFor a list of Furniture commands.\n\n";
specialNode.displayText = specialNode.displayText.Insert(num2, value3);
}
}
}
}
[HarmonyPatch(typeof(Terminal), "TextPostProcess")]
[HarmonyPrefix]
public static void TextPostProcessFurniture(ref string modifiedDisplayText, TerminalNode node)
{
if (modifiedDisplayText.Length > 0 && (modifiedDisplayText.Contains("[[[[furnitureUnlockablesSelectionList]]]]") || (modifiedDisplayText.Contains("[[[[") && modifiedDisplayText.Contains("]]]]"))))
{
int num = modifiedDisplayText.IndexOf("[[[[");
int num2 = modifiedDisplayText.IndexOf("]]]]") + 3;
string oldValue = modifiedDisplayText.Substring(num, num2 - num);
string text = "";
text = text + "Remaining furniture credit balance: $" + currentFurnitureCredits + ".\n";
text += "\n";
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < ShipFurnitureSelection.Count; i++)
{
stringBuilder.Append($"\n{ShipFurnitureSelection[i].creatureName} // ${ShipFurnitureSelection[i].itemCost}");
}
text += stringBuilder.ToString();
if (ShipFurnitureSelection == null || ShipFurnitureSelection.Count <= 0)
{
modifiedDisplayText = modifiedDisplayText.Replace("[[[[furnitureUnlockablesSelectionList]]]]", "[No items available]");
}
modifiedDisplayText = modifiedDisplayText.Replace(oldValue, text);
}
}
[HarmonyPatch(typeof(Terminal), "ParsePlayerSentence")]
[HarmonyPrefix]
public static bool ParsePlayerSentence(ref TerminalNode __result, Terminal __instance)
{
if (__instance.screenText.text.Length <= 0)
{
return true;
}
string text = __instance.screenText.text.Substring(__instance.screenText.text.Length - __instance.textAdded);
string[] array = text.Split(' ');
if (array.Length == 0)
{
return true;
}
if (!ConfigSync.isSynced)
{
if (text.StartsWith("furniture"))
{
__result = BuildTerminalNodeHomeFurniture();
return false;
}
return true;
}
if (text.StartsWith("furnitures"))
{
text = text.Replace("furnitures", "furniture");
}
if (text.StartsWith("furniture"))
{
if (text == "furniture")
{
__result = BuildTerminalNodeHomeFurniture();
return false;
}
text = text.Substring(6);
return true;
}
return true;
}
private static TerminalNode BuildTerminalNodeHomeFurniture()
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Expected O, but got Unknown
return new TerminalNode
{
displayText = "[CozyFurniture]\n\nStore\n------------------------------\n[[[[furnitureUnlockablesSelectionList]]]]\n\n",
clearPreviousText = true,
acceptAnything = false
};
}
private static TerminalNode BuildCustomTerminalNode(string displayText, bool clearPreviousText = false, bool acceptAnything = false, bool isConfirmationNode = false)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: 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_0023: Expected O, but got Unknown
return new TerminalNode
{
displayText = displayText,
clearPreviousText = clearPreviousText,
acceptAnything = false,
isConfirmationNode = isConfirmationNode
};
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "CozyFurniture";
public const string PLUGIN_NAME = "CozyFurniture";
public const string PLUGIN_VERSION = "1.0.0";
}
}
namespace CozyFurniture.NetcodePatcher
{
[AttributeUsage(AttributeTargets.Module)]
internal class NetcodePatchedAssemblyAttribute : Attribute
{
}
}
