MoveControllerBridge.cs

using System;
using System.Reflection;
using BepInEx.Logging;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;

namespace MoveControllerAxisSplit
{
    internal sealed class ButtonTarget
    {
        internal Button MoveXZButton;
    }

    internal sealed class MoveControllerBridge
    {
        private const BindingFlags AllStatic = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static;
        private const BindingFlags AllInstance = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;

        private readonly ManualLogSource _logger;
        private readonly Func<bool> _invertZ;
        private Assembly _assembly;
        private Type _pluginType;
        private Type _windowType;
        private Type _dragActionType;
        private Type _buttonManagerType;
        private Type _moveServiceType;
        private Type _undoServiceType;
        private Type _accessoryServiceType;
        private FieldInfo _windowField;
        private FieldInfo _guiField;
        private FieldInfo _allSelectedField;
        private PropertyInfo _ikSelectedProperty;
        private MethodInfo _dragButtonMethod;
        private MethodInfo _moveXZFactoryMethod;
        private MethodInfo _isAccessoryControlMethod;
        private MethodInfo _initUndoAccessoryMoveMethod;
        private MethodInfo _moveAccessoryMethod;
        private MethodInfo _createUndoAccessoryMoveMethod;
        private MethodInfo _checkIfIkSelectedMethod;
        private MethodInfo _moveIkMethod;
        private MethodInfo _moveObjMethod;
        private MethodInfo _resizeObjMethod;
        private MethodInfo _storeOldSizesMethod;
        private MethodInfo _storeOldIkPositionMethod;
        private MethodInfo _storeOldPositionsMethod;
        private MethodInfo _createUndoForResizeMethod;
        private MethodInfo _createUndoForIkMoveMethod;
        private MethodInfo _createUndoForMoveMethod;
        private bool _loggedConnection;

        internal MoveControllerBridge(ManualLogSource logger, Func<bool> invertZ)
        {
            _logger = logger;
            _invertZ = invertZ;
        }

        internal bool TryResolveTarget(out ButtonTarget target)
        {
            target = null;
            if (!TryInitialize())
                return false;

            object window;
            Canvas canvas;
            try
            {
                window = _windowField.GetValue(null);
                if (window == null)
                    return false;

                canvas = _guiField.GetValue(window) as Canvas;
            }
            catch (Exception ex)
            {
                LogError("Could not read the Move Controller window", ex);
                return false;
            }

            if (canvas == null)
                return false;

            Transform transform = canvas.transform.Find("MovePanel/MoveXZ");
            if (transform == null)
                return false;

            Button button = transform.GetComponent<Button>();
            if (button == null)
                return false;

            target = new ButtonTarget();
            target.MoveXZButton = button;
            return true;
        }

        internal bool BindAxisButton(Button button, Axis axis)
        {
            try
            {
                object action = Activator.CreateInstance(_dragActionType);
                SetAction(action, "StartDrag", delegate(BaseEventData data) { SafeEvent("start drag", delegate { StartDrag(data); }); });
                SetAction(action, "Drag", delegate(BaseEventData data) { SafeEvent("drag", delegate { Drag(axis, data); }); });
                SetAction(action, "EndDrag", delegate(BaseEventData data) { SafeEvent("end drag", delegate { EndDrag(data); }); });
                _dragButtonMethod.Invoke(null, new object[] { button, action });
                return true;
            }
            catch (Exception ex)
            {
                LogError("Could not bind the " + axis + " control", ex);
                return false;
            }
        }

        internal bool BindOriginalXZ(Button button)
        {
            try
            {
                object action = _moveXZFactoryMethod.Invoke(null,
                    new object[] { new Vector3(1f, 0f, 1f) });
                _dragButtonMethod.Invoke(null, new object[] { button, action });
                return true;
            }
            catch (Exception ex)
            {
                LogError("Could not restore the original XZ control", ex);
                return false;
            }
        }

        private bool TryInitialize()
        {
            if (_assembly != null)
                return true;

            Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
            for (int i = 0; i < assemblies.Length; i++)
            {
                if (string.Equals(assemblies[i].GetName().Name, "MoveControllerKOI", StringComparison.OrdinalIgnoreCase))
                {
                    _assembly = assemblies[i];
                    break;
                }
            }

            if (_assembly == null)
                return false;

            try
            {
                _pluginType = RequireType("MoveController.MoveCtrlPlugin");
                _windowType = RequireType("MoveController.MoveCtrlWindow");
                _dragActionType = RequireType("MoveController.DragButtonAction");
                _buttonManagerType = RequireType("MoveController.ButtonManager");
                _moveServiceType = RequireType("MoveController.MoveObjectService");
                _undoServiceType = RequireType("MoveController.UndoRedoService");
                _accessoryServiceType = RequireType("MoveController.AccessoryCtrlService");
                Type buttonActionManagerType = RequireType("MoveController.ButtonActionManager");

                _windowField = RequireField(_pluginType, "window", AllStatic);
                _guiField = RequireField(_windowType, "GUI", AllInstance);
                _allSelectedField = RequireField(_windowType, "AllSelected", AllInstance);
                _ikSelectedProperty = RequireProperty(_moveServiceType, "IkSelected", AllStatic);

                _dragButtonMethod = RequireMethod(_buttonManagerType, "DragButton", 2);
                _moveXZFactoryMethod = RequireMethod(buttonActionManagerType, "MoveXZ", 1);
                _isAccessoryControlMethod = RequireMethod(_accessoryServiceType, "IsAccessoryControl", 0);
                _initUndoAccessoryMoveMethod = RequireMethod(_accessoryServiceType, "InitUndoMove", 0);
                _moveAccessoryMethod = RequireMethod(_accessoryServiceType, "MoveAccessory", 1);
                _createUndoAccessoryMoveMethod = RequireMethod(_accessoryServiceType, "CreateUndoMove", 0);
                _checkIfIkSelectedMethod = RequireMethod(_moveServiceType, "CheckIfIkSelected", 0);
                _moveIkMethod = RequireMethod(_moveServiceType, "MoveIk", 1);
                _moveObjMethod = RequireMethod(_moveServiceType, "MoveObj", 2);
                _resizeObjMethod = RequireMethod(_moveServiceType, "resizeObj", 2);
                _storeOldSizesMethod = RequireMethod(_undoServiceType, "StoreOldSizes", 1);
                _storeOldIkPositionMethod = RequireMethod(_undoServiceType, "StoreOldIkPosition", 0);
                _storeOldPositionsMethod = RequireMethod(_undoServiceType, "StoreOldPositions", 1);
                _createUndoForResizeMethod = RequireMethod(_undoServiceType, "CreateUndoForResize", 1);
                _createUndoForIkMoveMethod = RequireMethod(_undoServiceType, "CreateUndoForIkMove", 0);
                _createUndoForMoveMethod = RequireMethod(_undoServiceType, "CreateUndoForMove", 1);

                if (!_loggedConnection)
                {
                    Version version = _assembly.GetName().Version;
                    _logger.LogInfo("Connected to MoveControllerKOI " + version + ".");
                    if (version == null || version.Major != 1 || version.Minor != 7 || version.Build != 1 ||
                        (version.Revision != 1 && version.Revision != 2))
                    {
                        _logger.LogWarning("This MoveControllerKOI version was not explicitly verified; attempting compatible attachment.");
                    }
                    _loggedConnection = true;
                }

                return true;
            }
            catch (Exception ex)
            {
                LogError("MoveControllerKOI has an incompatible structure", ex);
                _assembly = null;
                return false;
            }
        }

        private void StartDrag(BaseEventData data)
        {
            if (IsAccessoryControl())
            {
                Invoke(_initUndoAccessoryMoveMethod);
            }
            else if (IsRightButton(data))
            {
                Invoke(_storeOldSizesMethod, GetAllSelected());
            }
            else if ((bool)Invoke(_checkIfIkSelectedMethod))
            {
                Invoke(_storeOldIkPositionMethod);
            }
            else
            {
                Invoke(_storeOldPositionsMethod, GetAllSelected());
            }
        }

        private void Drag(Axis axis, BaseEventData data)
        {
            float input = Input.GetAxis("Mouse X");
            if (IsRightButton(data))
            {
                Invoke(_resizeObjMethod, GetAllSelected(), new Vector3(input, input, input));
                return;
            }

            if (axis == Axis.Z && _invertZ())
                input = -input;

            Vector3 worldInput = axis == Axis.X
                ? new Vector3(input, 0f, 0f)
                : new Vector3(0f, 0f, input);

            if (IsAccessoryControl())
            {
                Invoke(_moveAccessoryMethod, worldInput);
            }
            else if ((bool)_ikSelectedProperty.GetValue(null, null))
            {
                Invoke(_moveIkMethod, worldInput);
            }
            else
            {
                Invoke(_moveObjMethod, GetAllSelected(), worldInput);
            }
        }

        private void EndDrag(BaseEventData data)
        {
            if (IsAccessoryControl())
            {
                Invoke(_createUndoAccessoryMoveMethod);
            }
            else if (IsRightButton(data))
            {
                Invoke(_createUndoForResizeMethod, GetAllSelected());
            }
            else if ((bool)_ikSelectedProperty.GetValue(null, null))
            {
                Invoke(_createUndoForIkMoveMethod);
                _ikSelectedProperty.SetValue(null, false, null);
            }
            else
            {
                Invoke(_createUndoForMoveMethod, GetAllSelected());
            }
        }

        private object GetAllSelected()
        {
            object window = _windowField.GetValue(null);
            if (window == null)
                throw new InvalidOperationException("Move Controller window is not available.");
            return _allSelectedField.GetValue(window);
        }

        private bool IsAccessoryControl()
        {
            return (bool)Invoke(_isAccessoryControlMethod);
        }

        private static bool IsRightButton(BaseEventData data)
        {
            PointerEventData pointer = data as PointerEventData;
            return pointer != null && pointer.button == PointerEventData.InputButton.Right;
        }

        private void SetAction(object action, string propertyName, Action<BaseEventData> callback)
        {
            PropertyInfo property = RequireProperty(_dragActionType, propertyName, AllInstance);
            property.SetValue(action, callback, null);
        }

        private void SafeEvent(string operation, Action callback)
        {
            try
            {
                callback();
            }
            catch (Exception ex)
            {
                LogError("Move Controller axis " + operation + " failed", ex);
            }
        }

        private static object Invoke(MethodInfo method, params object[] arguments)
        {
            return method.Invoke(null, arguments);
        }

        private Type RequireType(string fullName)
        {
            Type type = _assembly.GetType(fullName, false);
            if (type == null)
                throw new MissingMemberException(fullName);
            return type;
        }

        private static FieldInfo RequireField(Type type, string name, BindingFlags flags)
        {
            FieldInfo field = type.GetField(name, flags);
            if (field == null)
                throw new MissingFieldException(type.FullName, name);
            return field;
        }

        private static PropertyInfo RequireProperty(Type type, string name, BindingFlags flags)
        {
            PropertyInfo property = type.GetProperty(name, flags);
            if (property == null)
                throw new MissingMemberException(type.FullName, name);
            return property;
        }

        private static MethodInfo RequireMethod(Type type, string name, int parameterCount)
        {
            MethodInfo[] methods = type.GetMethods(AllStatic);
            for (int i = 0; i < methods.Length; i++)
            {
                if (methods[i].Name == name && methods[i].GetParameters().Length == parameterCount)
                    return methods[i];
            }
            throw new MissingMethodException(type.FullName, name);
        }

        private void LogError(string message, Exception exception)
        {
            Exception actual = exception;
            while (actual is TargetInvocationException && actual.InnerException != null)
                actual = actual.InnerException;
            _logger.LogError(message + ": " + actual.Message);
        }
    }
}