Example #1
0
        static UserInput()
        {
            Fragment = Platform.UserInputFragment ?? throw Platform.APIException("UserInputAPI");

            Fragment.WndProcess = args =>
            {
                if (args.Message == WindowsMessages.MOUSEMOVE)
                {
                    var x = (short)args.LParam;
                    var y = (short)(args.LParam >> 16);

                    CursorPos2D = new Point(x, y);
                }

                OnWndProc.SafeInvoke(args);
            };
        }
Example #2
0
        protected override void WndProc(ref Message m)
        {
            if (m.Msg == 0x1c)
            {
                bool active = m.WParam != IntPtr.Zero;
                OnActivateApp(active);
            }

            OnWndProc?.Invoke(ref m);

            if (m.Result.ToInt32() < 0)
            {
                m.Result = new IntPtr(-m.Result.ToInt32() - 1);
                return;
            }

            base.WndProc(ref m);
        }
Example #3
0
        protected override void WndProc(ref Message m)
        {
            if (m.Msg == (uint)WindowsGameHost.WindowMessage.ActivateApplication)
            {
                bool active = m.WParam != IntPtr.Zero;
                OnActivateApp(active);
            }

            OnWndProc?.Invoke(ref m);

            if (m.Result.ToInt32() < 0)
            {
                m.Result = new IntPtr(-m.Result.ToInt32() - 1);
                return;
            }

            base.WndProc(ref m);
        }
Example #4
0
        public void Load()
        {
            _recv              = OnPluginRecv;
            _send              = OnPluginSend;
            _recv_new          = OnPluginRecv_new;
            _send_new          = OnPluginSend_new;
            _getPacketLength   = PacketsTable.GetPacketLength;
            _getPlayerPosition = GetPlayerPosition;
            _castSpell         = GameActions.CastSpell;
            _getStaticImage    = GetStaticImage;
            _getUoFilePath     = GetUOFilePath;
            _requestMove       = RequestMove;
            _setTitle          = SetWindowTitle;

            SDL.SDL_SysWMinfo info = new SDL.SDL_SysWMinfo();
            SDL.SDL_VERSION(out info.version);
            SDL.SDL_GetWindowWMInfo(SDL.SDL_GL_GetCurrentWindow(), ref info);

            IntPtr hwnd = IntPtr.Zero;

            if (info.subsystem == SDL.SDL_SYSWM_TYPE.SDL_SYSWM_WINDOWS)
            {
                hwnd = info.info.win.window;
            }

            PluginHeader header = new PluginHeader
            {
                ClientVersion     = (int)Client.Version,
                Recv              = Marshal.GetFunctionPointerForDelegate(_recv),
                Send              = Marshal.GetFunctionPointerForDelegate(_send),
                GetPacketLength   = Marshal.GetFunctionPointerForDelegate(_getPacketLength),
                GetPlayerPosition = Marshal.GetFunctionPointerForDelegate(_getPlayerPosition),
                CastSpell         = Marshal.GetFunctionPointerForDelegate(_castSpell),
                GetStaticImage    = Marshal.GetFunctionPointerForDelegate(_getStaticImage),
                HWND              = hwnd,
                GetUOFilePath     = Marshal.GetFunctionPointerForDelegate(_getUoFilePath),
                RequestMove       = Marshal.GetFunctionPointerForDelegate(_requestMove),
                SetTitle          = Marshal.GetFunctionPointerForDelegate(_setTitle),
                Recv_new          = Marshal.GetFunctionPointerForDelegate(_recv_new),
                Send_new          = Marshal.GetFunctionPointerForDelegate(_send_new),

                SDL_Window = Client.Game.Window.Handle
            };

            void *func = &header;

            if (Environment.OSVersion.Platform != PlatformID.Unix && Environment.OSVersion.Platform != PlatformID.MacOSX)
            {
                UnblockPath(Path.GetDirectoryName(_path));
            }

            try
            {
                IntPtr assptr = Native.LoadLibrary(_path);

                Log.Trace($"assembly: {assptr}");

                if (assptr == IntPtr.Zero)
                {
                    throw new Exception("Invalid Assembly, Attempting managed load.");
                }

                Log.Trace($"Searching for 'Install' entry point  -  {assptr}");

                IntPtr installPtr = Native.GetProcessAddress(assptr, "Install");

                Log.Trace($"Entry point: {installPtr}");

                if (installPtr == IntPtr.Zero)
                {
                    throw new Exception("Invalid Entry Point, Attempting managed load.");
                }

                Marshal.GetDelegateForFunctionPointer <OnInstall>(installPtr)(func);

                Console.WriteLine(">>> ADDRESS {0}", header.OnInitialize);
            }
            catch
            {
                try
                {
                    var asm  = Assembly.LoadFile(_path);
                    var type = asm.GetType("Assistant.Engine");

                    if (type == null)
                    {
                        Log.Error(
                            "Unable to find Plugin Type, API requires the public class Engine in namespace Assistant.");

                        return;
                    }

                    var meth = type.GetMethod("Install", BindingFlags.Public | BindingFlags.Static);

                    if (meth == null)
                    {
                        Log.Error("Engine class missing public static Install method Needs 'public static unsafe void Install(PluginHeader *plugin)' ");

                        return;
                    }

                    meth.Invoke(null, new object[] { (IntPtr)func });
                }
                catch (Exception err)
                {
                    Log.Error(
                        $"Plugin threw an error during Initialization. {err.Message} {err.StackTrace} {err.InnerException?.Message} {err.InnerException?.StackTrace}");

                    return;
                }
            }


            if (header.OnRecv != IntPtr.Zero)
            {
                _onRecv = Marshal.GetDelegateForFunctionPointer <OnPacketSendRecv>(header.OnRecv);
            }

            if (header.OnSend != IntPtr.Zero)
            {
                _onSend = Marshal.GetDelegateForFunctionPointer <OnPacketSendRecv>(header.OnSend);
            }

            if (header.OnHotkeyPressed != IntPtr.Zero)
            {
                _onHotkeyPressed = Marshal.GetDelegateForFunctionPointer <OnHotkey>(header.OnHotkeyPressed);
            }

            if (header.OnMouse != IntPtr.Zero)
            {
                _onMouse = Marshal.GetDelegateForFunctionPointer <OnMouse>(header.OnMouse);
            }

            if (header.OnPlayerPositionChanged != IntPtr.Zero)
            {
                _onUpdatePlayerPosition = Marshal.GetDelegateForFunctionPointer <OnUpdatePlayerPosition>(header.OnPlayerPositionChanged);
            }

            if (header.OnClientClosing != IntPtr.Zero)
            {
                _onClientClose = Marshal.GetDelegateForFunctionPointer <OnClientClose>(header.OnClientClosing);
            }

            if (header.OnInitialize != IntPtr.Zero)
            {
                _onInitialize = Marshal.GetDelegateForFunctionPointer <OnInitialize>(header.OnInitialize);
            }

            if (header.OnConnected != IntPtr.Zero)
            {
                _onConnected = Marshal.GetDelegateForFunctionPointer <OnConnected>(header.OnConnected);
            }

            if (header.OnDisconnected != IntPtr.Zero)
            {
                _onDisconnected = Marshal.GetDelegateForFunctionPointer <OnDisconnected>(header.OnDisconnected);
            }

            if (header.OnFocusGained != IntPtr.Zero)
            {
                _onFocusGained = Marshal.GetDelegateForFunctionPointer <OnFocusGained>(header.OnFocusGained);
            }

            if (header.OnFocusLost != IntPtr.Zero)
            {
                _onFocusLost = Marshal.GetDelegateForFunctionPointer <OnFocusLost>(header.OnFocusLost);
            }

            if (header.Tick != IntPtr.Zero)
            {
                _tick = Marshal.GetDelegateForFunctionPointer <OnTick>(header.Tick);
            }


            if (header.OnRecv_new != IntPtr.Zero)
            {
                _onRecv_new = Marshal.GetDelegateForFunctionPointer <OnPacketSendRecv_new>(header.OnRecv_new);
            }
            if (header.OnSend_new != IntPtr.Zero)
            {
                _onSend_new = Marshal.GetDelegateForFunctionPointer <OnPacketSendRecv_new>(header.OnSend_new);
            }

            if (header.OnDrawCmdList != IntPtr.Zero)
            {
                _draw_cmd_list = Marshal.GetDelegateForFunctionPointer <OnDrawCmdList>(header.OnDrawCmdList);
            }
            if (header.OnWndProc != IntPtr.Zero)
            {
                _on_wnd_proc = Marshal.GetDelegateForFunctionPointer <OnWndProc>(header.OnWndProc);
            }


            IsValid = true;

            _onInitialize?.Invoke();
        }
Example #5
0
 protected virtual void ProcessWndProc(WndProcEventArgs e)
 {
     OnWndProc?.Invoke(this, e);
 }
Example #6
0
 protected override void WndProc(ref Message m)
 {
     OnWndProc?.Invoke(this, m);
     base.WndProc(ref m);
 }