using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using OutwardModsCommunicator.EventBus;
using OutwardModsCommunicator.Managers;
using OutwardModsCommunicatorChatControl.Events;
using OutwardModsCommunicatorChatControl.Events.Publishers;
using OutwardModsCommunicatorChatControl.Utility.Enums;
using OutwardModsCommunicatorChatControl.Utility.Helpers;
using SideLoader;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("OutwardModsCommunicatorChatControl")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("OutwardModsCommunicatorChatControl")]
[assembly: AssemblyCopyright("Copyright © 2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("c5450fe0-edcf-483f-b9ea-4b1ef9d36da7")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace OutwardModsCommunicatorChatControl
{
[BepInPlugin("gymmed.mods_communicator_chat_control", "Mods Communicator Chat Control", "0.0.2")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class OMCCC : BaseUnityPlugin
{
public const string GUID = "gymmed.mods_communicator_chat_control";
public const string NAME = "Mods Communicator Chat Control";
public const string VERSION = "0.0.2";
public static string prefix = "[Mods-Communicator-Chat-Control]";
public const string EVENTS_LISTENER_GUID = "gymmed.mods_communicator_chat_control_*";
internal static ManualLogSource Log;
internal void Awake()
{
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
Log = ((BaseUnityPlugin)this).Logger;
LogMessage("Hello world from Mods Communicator Chat Control 0.0.2!");
new Harmony("gymmed.mods_communicator_chat_control").PatchAll();
EventBusPublisher.SendCommands();
}
internal void Update()
{
}
public static void LogMessage(string message)
{
Log.LogMessage((object)(prefix + " " + message));
}
public static void LogStatusMessage(string message, ChatLogStatus status = ChatLogStatus.Info)
{
LogMessage($"[{status}] {message}");
}
public static void LogSL(string message)
{
SL.Log(prefix + " " + message);
}
public static string GetProjectLocation()
{
return Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
}
}
}
namespace OutwardModsCommunicatorChatControl.Utility.Helpers
{
public static class CharacterHelpers
{
public static Character TryToFindOtherCharacterInLobby(Character mainCharacter, string otherCharName)
{
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
Character val = null;
foreach (PlayerSystem item in Global.Lobby.PlayersInLobby)
{
val = item.ControlledCharacter;
if ((Object)(object)val != (Object)null && val.UID != mainCharacter.UID && string.Equals(otherCharName, val.Name))
{
return val;
}
}
return null;
}
public static Character TryToFindOtherCharacterInLobby(Character mainCharacter)
{
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
Character val = null;
foreach (PlayerSystem item in Global.Lobby.PlayersInLobby)
{
val = item.ControlledCharacter;
if ((Object)(object)val != (Object)null && val.UID != mainCharacter.UID)
{
return val;
}
}
return val;
}
public static bool IsCharacterInDistance(Character firstCharacter, Character secondCharacter, float minimumDistance)
{
//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_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)
Vector3 val = ((Component)firstCharacter).transform.position - ((Component)secondCharacter).transform.position;
float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
float num = minimumDistance * minimumDistance;
if (sqrMagnitude > num)
{
return false;
}
return true;
}
public static bool HasManualMovement(Character character)
{
CharacterControl characterControl = character.CharacterControl;
LocalCharacterControl val = (LocalCharacterControl)(object)((characterControl is LocalCharacterControl) ? characterControl : null);
if (val == null)
{
return false;
}
if (((Vector2)(ref ((CharacterControl)val).m_moveInput)).sqrMagnitude > 0.01f)
{
return true;
}
return false;
}
}
public static class ChatHelpers
{
public static void SendChatLog(ChatPanel panel, string message, ChatLogStatus status = ChatLogStatus.Info)
{
panel.ChatMessageReceived("System", ChatLogStatusHelper.GetChatLogText(message, status));
}
public static void SendChatLog(Character character, string message, ChatLogStatus status = ChatLogStatus.Info)
{
CharacterUI characterUI = character.CharacterUI;
if ((Object)(object)((characterUI != null) ? characterUI.ChatPanel : null) == (Object)null)
{
OMCCC.LogMessage("ChatHelpers@SendChatLog provided character with missing chatPanel!");
}
else
{
SendChatLog(character.CharacterUI.ChatPanel, message, status);
}
}
public static void SendChatOrLog(Character character, string message, ChatLogStatus status = ChatLogStatus.Info)
{
CharacterUI characterUI = character.CharacterUI;
if ((Object)(object)((characterUI != null) ? characterUI.ChatPanel : null) == (Object)null)
{
OMCCC.LogStatusMessage(message, status);
}
else
{
SendChatLog(character.CharacterUI.ChatPanel, message, status);
}
}
}
public static class CollectionValueParser
{
public static (object result, string error) TryParse(Type collectionType, string valueString)
{
if (collectionType == null || string.IsNullOrWhiteSpace(valueString))
{
return (null, "Type or value is null/empty");
}
if (!IsCollectionType(collectionType))
{
return (null, "Type '" + collectionType.Name + "' is not a collection type");
}
Type elementType = GetElementType(collectionType);
if (elementType == null)
{
return (null, "Cannot determine element type for '" + collectionType.Name + "'");
}
string[] array = valueString.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (array.Length == 0)
{
return (null, "No values provided");
}
if (collectionType.IsArray)
{
return TryParseArray(elementType, array);
}
return TryParseCollection(collectionType, elementType, array);
}
private static (object result, string error) TryParseArray(Type elementType, string[] values)
{
List<object> list = new List<object>();
for (int i = 0; i < values.Length; i++)
{
var (item, text) = ParseValue(elementType, values[i]);
if (text != null)
{
return (null, $"Invalid value at position {i + 1}: {text}");
}
list.Add(item);
}
try
{
Array array = Array.CreateInstance(elementType, list.Count);
for (int j = 0; j < list.Count; j++)
{
array.SetValue(list[j], j);
}
return (array, null);
}
catch (Exception ex)
{
return (null, "Failed to create array: " + ex.Message);
}
}
private static (object result, string error) TryParseCollection(Type collectionType, Type elementType, string[] values)
{
List<object> list = new List<object>();
for (int i = 0; i < values.Length; i++)
{
var (item, text) = ParseValue(elementType, values[i]);
if (text != null)
{
return (null, $"Invalid value at position {i + 1}: {text}");
}
list.Add(item);
}
try
{
bool num = IsSetType(collectionType);
bool flag = IsListType(collectionType);
bool flag2 = typeof(ICollection).IsAssignableFrom(collectionType);
bool flag3 = typeof(IEnumerable).IsAssignableFrom(collectionType);
object obj;
if (num || (flag3 && !flag && collectionType.GetConstructor(Type.EmptyTypes) != null))
{
Type type = typeof(HashSet<>).MakeGenericType(elementType);
obj = Activator.CreateInstance(type);
MethodInfo method = type.GetMethod("Add");
foreach (object item2 in list)
{
method.Invoke(obj, new object[1] { item2 });
}
}
else if (flag || (flag2 && collectionType.GetConstructor(Type.EmptyTypes) != null))
{
Type type2 = typeof(List<>).MakeGenericType(elementType);
obj = Activator.CreateInstance(type2);
MethodInfo method2 = type2.GetMethod("Add");
foreach (object item3 in list)
{
method2.Invoke(obj, new object[1] { item3 });
}
}
else
{
if (!collectionType.IsAssignableFrom(typeof(List<>).MakeGenericType(elementType)))
{
return (null, "Cannot instantiate collection type '" + collectionType.Name + "'");
}
Type type3 = typeof(List<>).MakeGenericType(elementType);
obj = Activator.CreateInstance(type3);
MethodInfo method3 = type3.GetMethod("Add");
foreach (object item4 in list)
{
method3.Invoke(obj, new object[1] { item4 });
}
}
return (obj, null);
}
catch (Exception ex)
{
return (null, "Failed to create collection: " + ex.Message);
}
}
private static (object result, string error) ParseValue(Type targetType, string valueString)
{
if (string.IsNullOrWhiteSpace(valueString))
{
return (null, "Empty value");
}
valueString = valueString.Trim();
if (targetType.IsEnum)
{
try
{
return (Enum.Parse(targetType, valueString, ignoreCase: true), null);
}
catch
{
string text = string.Join(", ", Enum.GetNames(targetType));
return (null, "Invalid enum value. Expected one of: " + text);
}
}
(object value, string error) tuple = EventArgumentParser.TryParseScalar(targetType, valueString);
var (item, _) = tuple;
if (tuple.error == null)
{
return (item, null);
}
return (null, "Cannot convert '" + valueString + "' to " + targetType.Name);
}
public static bool IsCollectionType(Type type)
{
if (type == null)
{
return false;
}
if (type.IsArray)
{
return true;
}
if (typeof(IEnumerable).IsAssignableFrom(type))
{
if (type.IsGenericType)
{
Type genericTypeDefinition = type.GetGenericTypeDefinition();
if (genericTypeDefinition == typeof(HashSet<>) || genericTypeDefinition == typeof(List<>) || genericTypeDefinition == typeof(IList<>) || genericTypeDefinition == typeof(ICollection<>) || genericTypeDefinition == typeof(IEnumerable<>))
{
return true;
}
}
if (typeof(ICollection).IsAssignableFrom(type) && type.GetConstructor(Type.EmptyTypes) != null)
{
return true;
}
}
return false;
}
public static Type GetElementType(Type collectionType)
{
if (collectionType == null)
{
return null;
}
if (collectionType.IsArray)
{
return collectionType.GetElementType();
}
if (collectionType.IsGenericType)
{
Type[] genericArguments = collectionType.GetGenericArguments();
if (genericArguments.Length != 0)
{
return genericArguments[0];
}
}
Type[] interfaces = collectionType.GetInterfaces();
foreach (Type type in interfaces)
{
if (!type.IsGenericType)
{
continue;
}
Type genericTypeDefinition = type.GetGenericTypeDefinition();
if (genericTypeDefinition == typeof(IEnumerable<>) || genericTypeDefinition == typeof(ICollection<>) || genericTypeDefinition == typeof(IList<>))
{
Type[] genericArguments2 = type.GetGenericArguments();
if (genericArguments2.Length != 0)
{
return genericArguments2[0];
}
}
}
return null;
}
private static bool IsSetType(Type type)
{
if (type == null)
{
return false;
}
if (type.IsGenericType)
{
Type genericTypeDefinition = type.GetGenericTypeDefinition();
if (!(genericTypeDefinition == typeof(HashSet<>)))
{
return genericTypeDefinition == typeof(ISet<>);
}
return true;
}
return false;
}
private static bool IsListType(Type type)
{
if (type == null)
{
return false;
}
if (type.IsGenericType)
{
Type genericTypeDefinition = type.GetGenericTypeDefinition();
if (!(genericTypeDefinition == typeof(List<>)) && !(genericTypeDefinition == typeof(IList<>)))
{
return genericTypeDefinition == typeof(IList<>);
}
return true;
}
return typeof(IList).IsAssignableFrom(type);
}
}
public static class EventArgumentParser
{
private static readonly HashSet<Type> WhitelistedScalarTypes = new HashSet<Type>
{
typeof(string),
typeof(int),
typeof(float),
typeof(bool),
typeof(double),
typeof(long),
typeof(decimal),
typeof(char)
};
public static bool CanParse(Type type)
{
if (type == null)
{
return false;
}
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>))
{
return CanParse(Nullable.GetUnderlyingType(type));
}
if (WhitelistedScalarTypes.Contains(type))
{
return true;
}
if (type.IsEnum)
{
return true;
}
if (CollectionValueParser.IsCollectionType(type))
{
Type elementType = CollectionValueParser.GetElementType(type);
if (elementType != null)
{
return CanParseScalar(elementType);
}
return false;
}
return false;
}
private static bool CanParseScalar(Type type)
{
if (type == null)
{
return false;
}
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>))
{
return CanParseScalar(Nullable.GetUnderlyingType(type));
}
if (WhitelistedScalarTypes.Contains(type))
{
return true;
}
if (type.IsEnum)
{
return true;
}
return false;
}
public static bool IsEventPublishable(EventDefinition eventDef, out string unsupportedParam)
{
unsupportedParam = null;
object obj;
if (eventDef == null)
{
obj = null;
}
else
{
EventSchema schema = eventDef.Schema;
obj = ((schema != null) ? schema.Fields : null);
}
if (obj == null)
{
return true;
}
foreach (KeyValuePair<string, Type> field in eventDef.Schema.Fields)
{
if (!CanParse(field.Value))
{
unsupportedParam = field.Key;
return false;
}
}
return true;
}
public static (bool success, object value, string error) TryParseWithDetails(Type targetType, string valueString)
{
if (targetType == null)
{
return (false, null, "Target type is null");
}
if (string.IsNullOrEmpty(valueString))
{
return (false, null, "Value is null or empty");
}
if (targetType.IsGenericType && targetType.GetGenericTypeDefinition() == typeof(Nullable<>))
{
return TryParseWithDetails(Nullable.GetUnderlyingType(targetType), valueString);
}
if (CollectionValueParser.IsCollectionType(targetType))
{
var (item, text) = CollectionValueParser.TryParse(targetType, valueString);
return (text == null, item, text);
}
var (item2, text2) = TryParseScalar(targetType, valueString);
return (text2 == null, item2, text2);
}
public static bool TryParse(Type targetType, string value, out object result)
{
result = null;
if (value == null)
{
return false;
}
var (flag, obj, _) = TryParseWithDetails(targetType, value);
if (flag)
{
result = obj;
return true;
}
return false;
}
internal static (object value, string error) TryParseScalar(Type targetType, string valueString)
{
if (string.IsNullOrWhiteSpace(valueString))
{
return (null, "Empty value");
}
valueString = valueString.Trim();
if (targetType == typeof(string))
{
return (valueString, null);
}
if (targetType == typeof(int))
{
if (int.TryParse(valueString, out var result))
{
return (result, null);
}
return (null, "Cannot convert '" + valueString + "' to int");
}
if (targetType == typeof(float))
{
if (float.TryParse(valueString, out var result2))
{
return (result2, null);
}
return (null, "Cannot convert '" + valueString + "' to float");
}
if (targetType == typeof(double))
{
if (double.TryParse(valueString, out var result3))
{
return (result3, null);
}
return (null, "Cannot convert '" + valueString + "' to double");
}
if (targetType == typeof(long))
{
if (long.TryParse(valueString, out var result4))
{
return (result4, null);
}
return (null, "Cannot convert '" + valueString + "' to long");
}
if (targetType == typeof(decimal))
{
if (decimal.TryParse(valueString, out var result5))
{
return (result5, null);
}
return (null, "Cannot convert '" + valueString + "' to decimal");
}
if (targetType == typeof(bool))
{
switch (valueString.ToLowerInvariant())
{
case "true":
case "1":
case "yes":
case "on":
return (true, null);
case "false":
case "0":
case "no":
case "off":
return (false, null);
default:
return (null, "Cannot convert '" + valueString + "' to bool. Expected: true/false, 1/0, yes/no, on/off");
}
}
if (targetType == typeof(char))
{
if (char.TryParse(valueString, out var result6))
{
return (result6, null);
}
return (null, "Cannot convert '" + valueString + "' to char");
}
if (targetType.IsEnum)
{
try
{
return (Enum.Parse(targetType, valueString, ignoreCase: true), null);
}
catch
{
string text = string.Join(", ", Enum.GetNames(targetType));
return (null, "Invalid enum value. Expected one of: " + text);
}
}
return (null, "Cannot parse type " + targetType.Name);
}
}
public static class EventBusHelpers
{
public static IReadOnlyDictionary<string, Dictionary<string, EventDefinition>> GetRegisteredEvents()
{
return EventBus.GetRegisteredEvents();
}
public static bool TryGetEvent(string modNamespace, string eventName, out EventDefinition eventDef)
{
eventDef = null;
IReadOnlyDictionary<string, Dictionary<string, EventDefinition>> registeredEvents = GetRegisteredEvents();
if (registeredEvents == null)
{
return false;
}
if (!registeredEvents.TryGetValue(modNamespace, out var value))
{
return false;
}
return value.TryGetValue(eventName, out eventDef);
}
public static bool TryFindEvent(string eventName, out string foundNamespace, out EventDefinition eventDef)
{
eventDef = null;
foundNamespace = null;
IReadOnlyDictionary<string, Dictionary<string, EventDefinition>> registeredEvents = GetRegisteredEvents();
if (registeredEvents == null)
{
return false;
}
foreach (KeyValuePair<string, Dictionary<string, EventDefinition>> item in registeredEvents)
{
if (item.Value.TryGetValue(eventName, out eventDef))
{
foundNamespace = item.Key;
return true;
}
}
return false;
}
public static void SendEventNotFound(ChatPanel panel, string modNamespace, string eventName)
{
ChatHelpers.SendChatLog(panel, "Event '" + eventName + "' not found in mod '" + modNamespace + "'", ChatLogStatus.Error);
}
public static void SendModNotFound(ChatPanel panel, string modNamespace)
{
ChatHelpers.SendChatLog(panel, "Mod '" + modNamespace + "' not found", ChatLogStatus.Error);
}
public static void SendMissingParams(ChatPanel panel)
{
ChatHelpers.SendChatLog(panel, "Missing --mod or --event parameter. Usage: /event --mod=<namespace> --event=<name>", ChatLogStatus.Warning);
}
public static void SendEventInfo(ChatPanel panel, string modNamespace, string eventName, EventDefinition eventDef)
{
ChatHelpers.SendChatLog(panel, modNamespace + "." + eventName, ChatLogStatus.Success);
string text = (string.IsNullOrEmpty(eventDef.Description) ? "(no description)" : eventDef.Description);
ChatHelpers.SendChatLog(panel, "Description: " + text);
if (eventDef.Schema.Fields.Count > 0)
{
ChatHelpers.SendChatLog(panel, "Parameters:");
{
foreach (KeyValuePair<string, Type> field in eventDef.Schema.Fields)
{
string text2 = eventDef.Schema.GetDescription(field.Key) ?? "(no description)";
ChatHelpers.SendChatLog(panel, " - " + field.Key + " (" + GetTypeName(field.Value) + "): " + text2);
}
return;
}
}
ChatHelpers.SendChatLog(panel, "No parameters defined.");
}
private static string GetTypeName(Type type)
{
if (type == null)
{
return "Unknown";
}
if (type.IsGenericType)
{
string obj = type.Name.Split(new char[1] { '`' })[0];
string text = string.Join(", ", from t in type.GetGenericArguments()
select t.Name);
return obj + "<" + text + ">";
}
return type.Name;
}
}
public static class GenericTypeParser
{
private static readonly Dictionary<string, Type> SimpleTypeMap = new Dictionary<string, Type>(StringComparer.OrdinalIgnoreCase)
{
{
"string",
typeof(string)
},
{
"int",
typeof(int)
},
{
"bool",
typeof(bool)
},
{
"float",
typeof(float)
},
{
"double",
typeof(double)
},
{
"decimal",
typeof(decimal)
},
{
"long",
typeof(long)
},
{
"short",
typeof(short)
},
{
"byte",
typeof(byte)
},
{
"char",
typeof(char)
},
{
"object",
typeof(object)
},
{
"void",
typeof(void)
},
{
"hashset",
typeof(HashSet<>)
},
{
"list",
typeof(List<>)
},
{
"dictionary",
typeof(Dictionary<, >)
},
{
"queue",
typeof(Queue<>)
},
{
"stack",
typeof(Stack<>)
},
{
"set",
typeof(HashSet<>)
}
};
public static Type Parse(string typeString)
{
if (string.IsNullOrWhiteSpace(typeString))
{
return null;
}
typeString = typeString.Trim();
int num = typeString.IndexOf('[');
int num2 = typeString.IndexOf('<');
if (num >= 0 && (num2 < 0 || num < num2))
{
return ParseArrayType(typeString);
}
if (num2 >= 0)
{
return ParseGenericType(typeString);
}
return ParseSimpleType(typeString);
}
private static Type ParseArrayType(string typeString)
{
int num = typeString.IndexOf('[');
if (num < 0)
{
return null;
}
string typeString2 = typeString.Substring(0, num);
string text = typeString.Substring(num);
Type type = Parse(typeString2);
if (type == null)
{
return null;
}
if (text == "[]")
{
return type.MakeArrayType();
}
int num2 = 1;
for (int i = 1; i < text.Length; i++)
{
if (text[i] == ',')
{
num2++;
}
}
return type.MakeArrayType(num2);
}
private static Type ParseGenericType(string typeString)
{
int num = typeString.IndexOf('<');
int num2 = typeString.LastIndexOf('>');
if (num < 0 || num2 < 0 || num2 <= num)
{
return null;
}
string typeName = typeString.Substring(0, num);
List<Type> list = ParseGenericArguments(typeString.Substring(num + 1, num2 - num - 1));
if (list == null || list.Count == 0)
{
return null;
}
Type type = ParseSimpleType(typeName);
if (type == null)
{
return null;
}
try
{
return type.MakeGenericType(list.ToArray());
}
catch (Exception)
{
return null;
}
}
private static List<Type> ParseGenericArguments(string argsString)
{
List<Type> list = new List<Type>();
int num = 0;
int num2 = 0;
for (int i = 0; i <= argsString.Length; i++)
{
switch ((i < argsString.Length) ? argsString[i] : ',')
{
case '<':
case '[':
num++;
break;
case '>':
case ']':
num--;
break;
case ',':
{
if (num != 0)
{
break;
}
string text = argsString.Substring(num2, i - num2).Trim();
if (!string.IsNullOrEmpty(text))
{
Type type = Parse(text);
if (type == null)
{
return null;
}
list.Add(type);
}
num2 = i + 1;
break;
}
}
}
if (num2 < argsString.Length)
{
string text2 = argsString.Substring(num2).Trim();
if (!string.IsNullOrEmpty(text2))
{
Type type2 = Parse(text2);
if (type2 == null)
{
return null;
}
list.Add(type2);
}
}
return list;
}
private static Type ParseSimpleType(string typeName)
{
if (string.IsNullOrWhiteSpace(typeName))
{
return null;
}
typeName = typeName.Trim();
if (SimpleTypeMap.TryGetValue(typeName, out var value))
{
return value;
}
if (typeName.EndsWith("?"))
{
Type type = ParseSimpleType(typeName.Substring(0, typeName.Length - 1));
if (type != null)
{
return typeof(Nullable<>).MakeGenericType(type);
}
return null;
}
return FindTypeInAssemblies(typeName);
}
private static Type FindTypeInAssemblies(string typeName)
{
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
if (Enumerable.Contains(typeName, '.') || Enumerable.Contains(typeName, '+'))
{
Type type = TryResolveNestedClass(typeName);
if (type != null)
{
return type;
}
}
Assembly[] array = assemblies;
foreach (Assembly assembly in array)
{
try
{
Type type2 = assembly.GetType(typeName, throwOnError: false, ignoreCase: true);
if (type2 != null)
{
return type2;
}
}
catch
{
}
}
array = assemblies;
foreach (Assembly assembly2 in array)
{
try
{
string name = typeName;
int num = typeName.LastIndexOf('.');
if (num >= 0)
{
name = typeName.Substring(num + 1);
}
Type type3 = assembly2.GetType(name, throwOnError: false, ignoreCase: true);
if (type3 != null)
{
return type3;
}
}
catch
{
}
}
array = assemblies;
foreach (Assembly assembly3 in array)
{
try
{
Type[] types = assembly3.GetTypes();
foreach (Type type4 in types)
{
if (string.Equals(type4.Name, typeName, StringComparison.OrdinalIgnoreCase) || string.Equals(type4.FullName, typeName, StringComparison.OrdinalIgnoreCase))
{
return type4;
}
}
}
catch
{
}
}
return null;
}
private static Type TryResolveNestedClass(string typeName)
{
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
List<string> list = new List<string>();
list.Add(typeName);
if (Enumerable.Contains(typeName, '.'))
{
string[] array = typeName.Split(new char[1] { '.' });
for (int i = 1; i < array.Length; i++)
{
string item = string.Join(".", array, 0, array.Length - i) + "+" + string.Join("+", array, array.Length - i, i);
if (!list.Contains(item))
{
list.Add(item);
}
}
list.Add(typeName.Replace(".", "+"));
}
if (Enumerable.Contains(typeName, '+'))
{
string item2 = typeName.Replace("+", ".");
if (!list.Contains(item2))
{
list.Add(item2);
}
string[] array2 = typeName.Split(new char[1] { '+' });
for (int j = 1; j < array2.Length; j++)
{
string item3 = string.Join("+", array2, 0, array2.Length - j) + "." + string.Join(".", array2, array2.Length - j, j);
if (!list.Contains(item3))
{
list.Add(item3);
}
}
}
Assembly[] array3 = assemblies;
foreach (Assembly assembly in array3)
{
try
{
foreach (string item4 in list)
{
try
{
Type type = assembly.GetType(item4, throwOnError: false, ignoreCase: true);
if (type != null)
{
return type;
}
}
catch
{
}
}
}
catch
{
}
}
array3 = assemblies;
foreach (Assembly assembly2 in array3)
{
try
{
Type[] types = assembly2.GetTypes();
foreach (Type type2 in types)
{
string fullName = type2.FullName;
if (fullName != null)
{
string a = (Enumerable.Contains(fullName, '+') ? fullName.Substring(fullName.LastIndexOf('+') + 1) : (Enumerable.Contains(fullName, '.') ? fullName.Substring(fullName.LastIndexOf('.') + 1) : fullName));
string b = (Enumerable.Contains(typeName, '+') ? typeName.Substring(typeName.LastIndexOf('+') + 1) : (Enumerable.Contains(typeName, '.') ? typeName.Substring(typeName.LastIndexOf('.') + 1) : typeName));
if (string.Equals(a, b, StringComparison.OrdinalIgnoreCase))
{
return type2;
}
}
}
}
catch
{
}
}
return null;
}
public static bool IsGenericType(string typeString)
{
if (!string.IsNullOrWhiteSpace(typeString) && Enumerable.Contains(typeString, '<'))
{
return Enumerable.Contains(typeString, '>');
}
return false;
}
public static bool IsArrayType(string typeString)
{
if (!string.IsNullOrWhiteSpace(typeString) && Enumerable.Contains(typeString, '['))
{
return Enumerable.Contains(typeString, ']');
}
return false;
}
}
}
namespace OutwardModsCommunicatorChatControl.Utility.Enums
{
public enum ChatCommandsManagerParams
{
CommandName,
CommandParameters,
CommandAction,
IsCheatCommand,
CommandDescription,
CommandRequiresDebugMode
}
public static class ChatCommandsManagerParamsHelper
{
private static readonly Dictionary<ChatCommandsManagerParams, (string key, Type type)> _registry = new Dictionary<ChatCommandsManagerParams, (string, Type)>
{
[ChatCommandsManagerParams.CommandName] = ("command", typeof(string)),
[ChatCommandsManagerParams.CommandParameters] = ("parameters", typeof(Dictionary<string, (string, string)>)),
[ChatCommandsManagerParams.CommandAction] = ("function", typeof(Action<Character, Dictionary<string, string>>)),
[ChatCommandsManagerParams.IsCheatCommand] = ("isCheatCommand", typeof(bool)),
[ChatCommandsManagerParams.CommandDescription] = ("description", typeof(string)),
[ChatCommandsManagerParams.CommandRequiresDebugMode] = ("debugMode", typeof(bool))
};
public static (string key, Type type) Get(ChatCommandsManagerParams param)
{
return _registry[param];
}
}
public enum ChatLogStatus
{
Info,
Success,
Warning,
Error
}
public static class ChatLogStatusHelper
{
public static string GetChatLogText(string message, ChatLogStatus status = ChatLogStatus.Info)
{
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
return status switch
{
ChatLogStatus.Success => Global.SetTextColor(message, Global.LIGHT_GREEN),
ChatLogStatus.Warning => Global.SetTextColor(message, Global.LIGHT_ORANGE),
ChatLogStatus.Error => "<color=#" + UnityEngineExtensions.ToHex(Global.LIGHT_RED) + ">" + message + "</color>",
_ => message,
};
}
}
}
namespace OutwardModsCommunicatorChatControl.Tests
{
public static class EventArgumentParserTests
{
public static void RunAllTests()
{
try
{
OMCCC.LogMessage("[TEST] Starting EventArgumentParser tests...");
TestScalarInt();
TestScalarFloat();
TestScalarBool();
TestScalarString();
TestScalarChar();
TestScalarEnum();
TestArrayInt();
TestArrayString();
TestArrayEnum();
TestListInt();
TestHashSetInt();
TestIEnumerableInt();
TestScalarIntError();
TestArrayIntError();
TestEnumError();
OMCCC.LogMessage("[TEST] All EventArgumentParser tests completed successfully!");
}
catch (Exception ex)
{
OMCCC.LogMessage("[TEST ERROR] Test suite failed: " + ex.Message + "\n" + ex.StackTrace);
}
}
private static void TestScalarInt()
{
var (condition, obj, _) = EventArgumentParser.TryParseWithDetails(typeof(int), "42");
Assert(condition, "int parsing should succeed");
Assert(obj is int && (int)obj == 42, "int value should be 42");
OMCCC.LogMessage("[PASS] Scalar int test");
}
private static void TestScalarFloat()
{
var (condition, obj, _) = EventArgumentParser.TryParseWithDetails(typeof(float), "3.14");
Assert(condition, "float parsing should succeed");
Assert(obj is float && Math.Abs((float)obj - 3.14f) < 0.01f, "float value should be ~3.14");
OMCCC.LogMessage("[PASS] Scalar float test");
}
private static void TestScalarBool()
{
var (flag, obj, _) = EventArgumentParser.TryParseWithDetails(typeof(bool), "true");
Assert(flag && (bool)obj, "bool 'true' should parse");
var (flag2, obj2, _) = EventArgumentParser.TryParseWithDetails(typeof(bool), "yes");
Assert(flag2 && (bool)obj2, "bool 'yes' should parse");
var (flag3, obj3, _) = EventArgumentParser.TryParseWithDetails(typeof(bool), "false");
Assert(flag3 && !(bool)obj3, "bool 'false' should parse");
var (flag4, obj4, _) = EventArgumentParser.TryParseWithDetails(typeof(bool), "0");
Assert(flag4 && !(bool)obj4, "bool '0' should parse as false");
OMCCC.LogMessage("[PASS] Scalar bool test");
}
private static void TestScalarString()
{
var (flag, obj, _) = EventArgumentParser.TryParseWithDetails(typeof(string), "hello");
Assert(flag && (string)obj == "hello", "string parsing should succeed");
OMCCC.LogMessage("[PASS] Scalar string test");
}
private static void TestScalarChar()
{
var (flag, obj, _) = EventArgumentParser.TryParseWithDetails(typeof(char), "A");
Assert(flag && (char)obj == 'A', "char parsing should succeed");
OMCCC.LogMessage("[PASS] Scalar char test");
}
private static void TestScalarEnum()
{
var (flag, obj, _) = EventArgumentParser.TryParseWithDetails(typeof(DayOfWeek), "Monday");
Assert(flag && (DayOfWeek)obj == DayOfWeek.Monday, "enum parsing should succeed");
var (flag2, obj2, _) = EventArgumentParser.TryParseWithDetails(typeof(DayOfWeek), "monday");
Assert(flag2 && (DayOfWeek)obj2 == DayOfWeek.Monday, "enum parsing should be case-insensitive");
OMCCC.LogMessage("[PASS] Scalar enum test");
}
private static void TestArrayInt()
{
var (condition, obj, _) = EventArgumentParser.TryParseWithDetails(typeof(int[]), "1 2 3");
Assert(condition, "int array parsing should succeed");
Assert(obj is int[] array && array.Length == 3 && array[0] == 1 && array[1] == 2 && array[2] == 3, "int array should be [1,2,3]");
OMCCC.LogMessage("[PASS] Array int test");
}
private static void TestArrayString()
{
var (condition, obj, _) = EventArgumentParser.TryParseWithDetails(typeof(string[]), "hello world test");
Assert(condition, "string array parsing should succeed");
Assert(obj is string[] array && array.Length == 3 && array[0] == "hello" && array[1] == "world" && array[2] == "test", "string array should be correct");
OMCCC.LogMessage("[PASS] Array string test");
}
private static void TestArrayEnum()
{
var (condition, obj, _) = EventArgumentParser.TryParseWithDetails(typeof(DayOfWeek[]), "Monday Wednesday Friday");
Assert(condition, "enum array parsing should succeed");
Assert(obj is DayOfWeek[] array && array.Length == 3 && array[0] == DayOfWeek.Monday && array[1] == DayOfWeek.Wednesday, "enum array should be correct");
OMCCC.LogMessage("[PASS] Array enum test");
}
private static void TestListInt()
{
var (condition, obj, _) = EventArgumentParser.TryParseWithDetails(typeof(List<int>), "10 20 30");
Assert(condition, "List<int> parsing should succeed");
Assert(obj is List<int> list && list.Count == 3 && list[0] == 10 && list[1] == 20, "List<int> should contain correct values");
OMCCC.LogMessage("[PASS] Collection List<int> test");
}
private static void TestHashSetInt()
{
var (condition, obj, _) = EventArgumentParser.TryParseWithDetails(typeof(HashSet<int>), "5 10 15");
Assert(condition, "HashSet<int> parsing should succeed");
Assert(obj is HashSet<int> hashSet && hashSet.Count == 3 && hashSet.Contains(5) && hashSet.Contains(10), "HashSet<int> should contain correct values");
OMCCC.LogMessage("[PASS] Collection HashSet<int> test");
}
private static void TestIEnumerableInt()
{
var (condition, obj, _) = EventArgumentParser.TryParseWithDetails(typeof(IEnumerable<int>), "7 8 9");
Assert(condition, "IEnumerable<int> parsing should succeed");
Assert(obj != null, "IEnumerable<int> should not be null");
List<int> list = ((IEnumerable<int>)obj).ToList();
Assert(list.Count == 3 && list[0] == 7 && list[1] == 8, "IEnumerable<int> should contain correct values");
OMCCC.LogMessage("[PASS] Collection IEnumerable<int> test");
}
private static void TestScalarIntError()
{
var (flag, _, text) = EventArgumentParser.TryParseWithDetails(typeof(int), "abc");
Assert(!flag, "int parsing of 'abc' should fail");
Assert(text != null && !string.IsNullOrEmpty(text), "error message should be provided");
OMCCC.LogMessage("[PASS] Scalar int error test (error: " + text + ")");
}
private static void TestArrayIntError()
{
var (flag, _, text) = EventArgumentParser.TryParseWithDetails(typeof(int[]), "1 2 abc 4");
Assert(!flag, "int array parsing with invalid element should fail");
Assert(text?.Contains("position") ?? false, "error should indicate position");
OMCCC.LogMessage("[PASS] Array int error test (error: " + text + ")");
}
private static void TestEnumError()
{
var (flag, _, text) = EventArgumentParser.TryParseWithDetails(typeof(DayOfWeek), "InvalidDay");
Assert(!flag, "enum parsing of invalid value should fail");
Assert(text?.Contains("Expected one of") ?? false, "error should list valid options");
OMCCC.LogMessage("[PASS] Enum error test (error: " + text + ")");
}
private static void Assert(bool condition, string message)
{
if (!condition)
{
throw new Exception("Assertion failed: " + message);
}
}
}
}
namespace OutwardModsCommunicatorChatControl.Managers
{
public class PathsManager
{
private static PathsManager _instance;
public string configPath = "";
public string xmlFilePath = "";
public static PathsManager Instance
{
get
{
if (_instance == null)
{
_instance = new PathsManager();
}
return _instance;
}
}
private PathsManager()
{
configPath = Path.Combine(PathsManager.ConfigPath, "Chat_Commands_Template");
xmlFilePath = Path.Combine(configPath, "MyDocument.xml");
}
}
}
namespace OutwardModsCommunicatorChatControl.Events
{
public static class EventBusPublisher
{
public const string Event_AddCommand = "ChatCommandsManager@AddChatCommand";
public const string Event_RemoveCommand = "ChatCommandsManager@RemoveChatCommand";
public const string ChatCommands_Listener = "gymmed.chat_commands_manager_*";
public static void SendCommands()
{
ListEventsPublisher.SendListEventsCommand();
GetEventPublisher.SendGetEventCommand();
PublishEventPublisher.SendPublishCommand();
}
}
public static class EventBusRegister
{
public static void RegisterEvents()
{
}
}
public static class EventBusSubscriber
{
public const string Event_AddedChatCommand = "ChatCommandsManager@AddChatCommand_After";
public const string Event_RemovedChatCommand = "ChatCommandsManager@RemoveChatCommand_After";
public static void AddSubscribers()
{
EventBus.Subscribe("gymmed.chat_commands_manager_*", "ChatCommandsManager@AddChatCommand_After", (Action<EventPayload>)AddedChatCommand);
EventBus.Subscribe("gymmed.chat_commands_manager_*", "ChatCommandsManager@RemoveChatCommand_After", (Action<EventPayload>)RemovedChatCommand);
}
public static void AddedChatCommand(EventPayload payload)
{
if (payload != null)
{
(string, Type) tuple = ChatCommandsManagerParamsHelper.Get(ChatCommandsManagerParams.CommandName);
payload.Get<string>(tuple.Item1, (string)null);
OMCCC.LogMessage("Added command " + tuple.Item1);
}
}
public static void RemovedChatCommand(EventPayload payload)
{
if (payload != null)
{
(string, Type) tuple = ChatCommandsManagerParamsHelper.Get(ChatCommandsManagerParams.CommandName);
payload.Get<string>(tuple.Item1, (string)null);
OMCCC.LogMessage("Removed command " + tuple.Item1);
}
}
}
}
namespace OutwardModsCommunicatorChatControl.Events.Publishers
{
public static class GetEventPublisher
{
public static void SendGetEventCommand()
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Expected O, but got Unknown
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Expected O, but got Unknown
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Expected O, but got Unknown
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
//IL_009e: Expected O, but got Unknown
//IL_009f: Expected O, but got Unknown
Action<Character, Dictionary<string, string>> value = TriggerFunction;
EventPayload val = new EventPayload { };
string item;
((Dictionary<string, object>)val)[item] = "event";
string item2 = ChatCommandsManagerParamsHelper.Get(ChatCommandsManagerParams.CommandParameters).key;
((Dictionary<string, object>)val)[item2] = new Dictionary<string, (string, string)>
{
{
"mod",
("Mod namespace (optional if searching all mods).", null)
},
{
"event",
("Event name to look up.", null)
}
};
string item3 = ChatCommandsManagerParamsHelper.Get(ChatCommandsManagerParams.CommandAction).key;
((Dictionary<string, object>)val)[item3] = value;
string item4 = ChatCommandsManagerParamsHelper.Get(ChatCommandsManagerParams.CommandDescription).key;
((Dictionary<string, object>)val)[item4] = "Gets detailed information about a specific event, including proper type information for collections (HashSet, List, arrays), enums, and other supported types.";
EventPayload val2 = val;
EventBus.Publish("gymmed.chat_commands_manager_*", "ChatCommandsManager@AddChatCommand", val2);
}
public static void TriggerFunction(Character caller, Dictionary<string, string> arguments)
{
object obj;
if (caller == null)
{
obj = null;
}
else
{
CharacterUI characterUI = caller.CharacterUI;
obj = ((characterUI != null) ? characterUI.ChatPanel : null);
}
ChatPanel val = (ChatPanel)obj;
if ((Object)(object)val == (Object)null)
{
OMCCC.LogMessage("GetEventPublisher@TriggerFunction: No chat panel found");
return;
}
arguments.TryGetValue("mod", out var value);
arguments.TryGetValue("event", out var value2);
if (string.IsNullOrEmpty(value2))
{
EventBusHelpers.SendMissingParams(val);
return;
}
EventDefinition eventDef;
string foundNamespace;
if (!string.IsNullOrEmpty(value))
{
if (!EventBusHelpers.TryGetEvent(value, value2, out eventDef))
{
EventBusHelpers.SendEventNotFound(val, value, value2);
return;
}
foundNamespace = value;
}
else if (!EventBusHelpers.TryFindEvent(value2, out foundNamespace, out eventDef))
{
ChatHelpers.SendChatLog(val, "Event '" + value2 + "' not found in any mod", ChatLogStatus.Error);
return;
}
EventBusHelpers.SendEventInfo(val, foundNamespace, value2, eventDef);
}
}
public static class ListEventsPublisher
{
public static void SendListEventsCommand()
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Expected O, but got Unknown
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Expected O, but got Unknown
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Expected O, but got Unknown
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_0072: Expected O, but got Unknown
//IL_0073: Expected O, but got Unknown
Action<Character, Dictionary<string, string>> value = TriggerFunction;
EventPayload val = new EventPayload { };
string item;
((Dictionary<string, object>)val)[item] = "events";
string item2 = ChatCommandsManagerParamsHelper.Get(ChatCommandsManagerParams.CommandParameters).key;
((Dictionary<string, object>)val)[item2] = new Dictionary<string, (string, string)>();
string item3 = ChatCommandsManagerParamsHelper.Get(ChatCommandsManagerParams.CommandAction).key;
((Dictionary<string, object>)val)[item3] = value;
string item4 = ChatCommandsManagerParamsHelper.Get(ChatCommandsManagerParams.CommandDescription).key;
((Dictionary<string, object>)val)[item4] = "Lists all registered events from OutwardModsCommunicator.";
EventPayload val2 = val;
EventBus.Publish("gymmed.chat_commands_manager_*", "ChatCommandsManager@AddChatCommand", val2);
}
public static void TriggerFunction(Character caller, Dictionary<string, string> arguments)
{
object obj;
if (caller == null)
{
obj = null;
}
else
{
CharacterUI characterUI = caller.CharacterUI;
obj = ((characterUI != null) ? characterUI.ChatPanel : null);
}
ChatPanel val = (ChatPanel)obj;
if ((Object)(object)val == (Object)null)
{
OMCCC.LogMessage("ListEventsPublisher@TriggerFunction: No chat panel found");
return;
}
IReadOnlyDictionary<string, Dictionary<string, EventDefinition>> registeredEvents = EventBusHelpers.GetRegisteredEvents();
if (registeredEvents == null || registeredEvents.Count == 0)
{
ChatHelpers.SendChatLog(val, "0 events registered");
return;
}
int num = registeredEvents.Values.Sum((Dictionary<string, EventDefinition> modEvents) => modEvents.Count);
ChatHelpers.SendChatLog(val, $"{num} events registered", ChatLogStatus.Success);
foreach (KeyValuePair<string, Dictionary<string, EventDefinition>> item in registeredEvents)
{
ChatHelpers.SendChatLog(val, "Mod: " + item.Key);
foreach (KeyValuePair<string, EventDefinition> item2 in item.Value)
{
string key = item2.Key;
string text = (string.IsNullOrEmpty(item2.Value.Description) ? "(no description)" : item2.Value.Description);
ChatHelpers.SendChatLog(val, " - " + key + ": " + text);
}
}
}
}
public static class PublishEventPublisher
{
public static void SendPublishCommand()
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Expected O, but got Unknown
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Expected O, but got Unknown
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Expected O, but got Unknown
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
//IL_009e: Expected O, but got Unknown
//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
//IL_00b9: Expected O, but got Unknown
//IL_00ba: Expected O, but got Unknown
Action<Character, Dictionary<string, string>> value = TriggerFunction;
EventPayload val = new EventPayload { };
string item;
((Dictionary<string, object>)val)[item] = "publish";
string item2 = ChatCommandsManagerParamsHelper.Get(ChatCommandsManagerParams.CommandParameters).key;
((Dictionary<string, object>)val)[item2] = new Dictionary<string, (string, string)>
{
{
"mod",
("Mod namespace (optional if searching all mods).", null)
},
{
"event",
("Event name.", null)
}
};
string item3 = ChatCommandsManagerParamsHelper.Get(ChatCommandsManagerParams.CommandAction).key;
((Dictionary<string, object>)val)[item3] = value;
string item4 = ChatCommandsManagerParamsHelper.Get(ChatCommandsManagerParams.CommandDescription).key;
((Dictionary<string, object>)val)[item4] = "Publishes an event to OutwardModsCommunicator with proper type casting for collections (HashSet, List, arrays), enums, and other types. Usage: /publish [mod] event [--param=value...]";
string item5 = ChatCommandsManagerParamsHelper.Get(ChatCommandsManagerParams.CommandRequiresDebugMode).key;
((Dictionary<string, object>)val)[item5] = true;
EventPayload val2 = val;
EventBus.Publish("gymmed.chat_commands_manager_*", "ChatCommandsManager@AddChatCommand", val2);
}
public static void TriggerFunction(Character caller, Dictionary<string, string> arguments)
{
//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
//IL_00ce: Expected O, but got Unknown
object obj;
if (caller == null)
{
obj = null;
}
else
{
CharacterUI characterUI = caller.CharacterUI;
obj = ((characterUI != null) ? characterUI.ChatPanel : null);
}
ChatPanel val = (ChatPanel)obj;
if ((Object)(object)val == (Object)null)
{
OMCCC.LogMessage("PublishEventPublisher@TriggerFunction: No chat panel found");
return;
}
arguments.TryGetValue("mod", out var value);
arguments.TryGetValue("event", out var value2);
if (string.IsNullOrEmpty(value2))
{
SendUsageError(val);
return;
}
EventDefinition eventDef;
string foundNamespace;
if (!string.IsNullOrEmpty(value))
{
if (!EventBusHelpers.TryGetEvent(value, value2, out eventDef))
{
ChatHelpers.SendChatLog(val, "Event '" + value2 + "' not found in mod '" + value + "'", ChatLogStatus.Error);
return;
}
foundNamespace = value;
}
else if (!EventBusHelpers.TryFindEvent(value2, out foundNamespace, out eventDef))
{
ChatHelpers.SendChatLog(val, "Event '" + value2 + "' not found in any mod", ChatLogStatus.Error);
return;
}
EventPayload val2 = new EventPayload();
List<string> list = new List<string>();
EventSchema schema = eventDef.Schema;
Dictionary<string, Type>.KeyCollection source = ((schema == null) ? null : schema.Fields?.Keys) ?? new Dictionary<string, Type>().Keys;
foreach (KeyValuePair<string, string> argument in arguments)
{
string key = argument.Key;
string value3 = argument.Value;
if (key == "mod" || key == "event")
{
continue;
}
if (source.Contains(key))
{
Type type = eventDef.Schema.Fields[key];
var (flag, value4, text) = EventArgumentParser.TryParseWithDetails(type, value3);
if (flag)
{
((Dictionary<string, object>)(object)val2)[key] = value4;
continue;
}
list.Add("Parameter '" + key + "' (" + type.Name + "): " + (text ?? "Unknown error"));
}
else
{
object obj2 = TryAutoDetectAndParse(value3);
if (obj2 != null)
{
((Dictionary<string, object>)(object)val2)[key] = obj2;
ChatHelpers.SendChatLog(val, "Dynamic parameter '" + key + "' auto-detected as " + obj2.GetType().Name);
}
}
}
if (list.Count > 0)
{
foreach (string item in list)
{
ChatHelpers.SendChatLog(val, item, ChatLogStatus.Error);
}
return;
}
EventBus.Publish(foundNamespace, value2, val2);
ChatHelpers.SendChatLog(val, "Published event '" + foundNamespace + "." + value2 + "'", ChatLogStatus.Success);
}
private static object TryAutoDetectAndParse(string valueString)
{
if (string.IsNullOrWhiteSpace(valueString))
{
return null;
}
valueString = valueString.Trim();
string[] array = valueString.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (array.Length > 1)
{
if (array.All((string p) => int.TryParse(p, out var _)))
{
int[] array2 = new int[array.Length];
for (int i = 0; i < array.Length; i++)
{
int.TryParse(array[i], out array2[i]);
}
return array2;
}
return array;
}
if (int.TryParse(valueString, out var result))
{
return result;
}
if (bool.TryParse(valueString, out var result2))
{
return result2;
}
return valueString;
}
private static void SendUsageError(ChatPanel panel)
{
ChatHelpers.SendChatLog(panel, "Missing --event parameter. Usage: /publish <mod> <event> [--param=value...]", ChatLogStatus.Warning);
}
}
}
