Skip to content

EN UO Topic mouse keyboard

Jump to bottom
Codex edited this page Oct 12, 2026 · 4 revisions

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

Mouse & Keyboard

Home · C# · IDE · UO API · A–Z · Examples · Languages

Mouse and keyboard input. Screen coordinates, world cells, and coordinates inside a gump have different meanings.

Sections

Topic Commands and explanations
Click UO.Click
LClick UO.LClick
RClick UO.RClick
DoubleClick UO.LDblClick · UO.RDblClick
KeyPress UO.KeyPress
Press UO.Press

All theme commands

Input

UO.Click · UO.LClick · UO.RClick · UO.LDblClick · UO.RDblClick · UO.KeyPress · UO.Press

Examples on the topic

Each command card has several independent scenarios: direct code, functions and classes. Below are selected short scenarios; restrictions and full analysis are in the cards.

UO.LClick

Parameters, result and all scenarios

UO.LClick(100, 100);

UO.KeyPress

Parameters, result and all scenarios

UO.KeyPress(0x70);

Complete command reference

UO.Click

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# signatures

void UO.Click(object? name);

Sends a single click on an object via GameActions.SingleClick.

Parameters

  • name — Serial of the object or supported name of self/backpack/lasttarget/saved object; numeric strings and 0x strings are resolved by runtime.

Return value

void - no return value.

Behavior

  • Click resolves the link via ObjectChecked. ClickOnObject first uses Arg for serial and calls Click(int). This is a request for the item's signature/information, not DoubleClick or use of the item. The server response comes asynchronously.

Standalone C# scripts

Each example can be saved as a separate file .csx and run in IDE. The UO object and wait functions provide the host of the current game session. Replace demo serial names, coordinates and addresses with your own.

Simple example

Run this code as a separate .csx file. Arguments appear directly in the call; replace demonstration names, serials and addresses with your own.

The command is a separate statement. The message before it marks the start of the call; it does not confirm a server action.

UO.Print("Calling UO.Click");
UO.Click("self");

1. Click on character - direct script

Parameters and execution flow:

  • A single click is sent to self.
UO.Click("self");

2. Click last target - script function

Parameters and execution flow:

  • Before sending, the local existence of the target is checked.
return  RunScenario();
 object? RunScenario()
{
    var target = UO.LastTarget();
    if (Truth(UO.Exists(target)))
    {
        UO.Click(target);
    }

    return null;
}

bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;

3. They will click on the backpack - script class

Parameters and execution flow:

  • Single clicking on a backpack does not open it like double clicking it.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var bag = UO.Backpack();
        if (Truth(bag != 0))
        {
            UO.Click(bag);
        }

        return null;
    }

    bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}

Command implementation

C# is case sensitive. Use the exact UO name. Compare numeric flags with 0; use bool only where the signature returns bool.

UO.Click(name) — UO.Click(Any)

Parameters: name (Any)

Result: void / Unit.

During a call:

Internal implementation code; this is not a standalone script.

public void Click(InjectionValue name) => ObjectChecked(name, id => Click(id));

UO.KeyPress

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# signatures

void UO.KeyPress(object? key);
void UO.KeyPress(object? key, object? count);
void UO.KeyPress(object? key, object? count, object? delay);

Synthesizes one or more virtual-key presses.

Parameters

  • key - int virtual-key Windows, converted to byte. It is not a character string, nor is it a ID target.
  • count — Optional number of repetitions, default 1. 0/negative - no pressing or waiting.
  • delay - Optional pause of milliseconds after each press, including the last one; default is 105. Passed bridge.Wait without further restriction by this function.

Return value

void - no value. Call on a separate line; completion does not confirm the server's action.

Behavior

  • Press forwards all forms to KeyPress. KeyPress executes a loop count>0: bridge.KeyPress(key), bridge.Wait(delay), count--. Bridge sends user32 keybd_event down/up.
  • Requires open Graphics ClassicUO with input focus; otherwise RequireGameInput throws an error. The click processes the current interface/macro, the result of the server command is not returned.

Standalone C# scripts

Each example can be saved as a separate file .csx and run in IDE. The UO object and wait functions provide the host of the current game session. Replace demo serial names, coordinates and addresses with your own.

Simple example

Run this code as a separate .csx file. Arguments appear directly in the call; replace demonstration names, serials and addresses with your own.

The command is a separate statement. The message before it marks the start of the call; it does not confirm a server action.

UO.Print("Calling UO.KeyPress");
UO.KeyPress(0x70);

1. Direct call - direct script

Parameters and execution flow:

  • Synthesizes one or more virtual-key presses.
UO.KeyPress(0x70);

2. Explicit option - script function

Parameters and execution flow:

  • Press forwards all forms to KeyPress. KeyPress executes a loop count>0: bridge.KeyPress(key), bridge.Wait(delay), count--. Bridge sends user32 keybd_event down/up.
return  RunScenario();
 object? RunScenario()
{
    UO.KeyPress(0x70, 2, 250);
    return null;
}

3. Full Helper Function - Script Class

Parameters and execution flow:

  • Requires open Graphics ClassicUO with input focus; otherwise RequireGameInput throws an error. The click processes the current interface/macro, the result of the server command is not returned.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        UO.KeyPress(0x70, 0);
        UO.Print("Zero count sends no key");
        return null;
    }
}

Command implementation

C# is case sensitive. Use the exact UO name. Compare numeric flags with 0; use bool only where the signature returns bool.

UO.KeyPress(key) — UO.KeyPress(Integer)

Parameters: key (Integer)

Result: void / Unit.

During a call:

Internal implementation code; this is not a standalone script.

public void KeyPress(int key) => KeyPress(key, 1);

UO.KeyPress(key, count) — UO.KeyPress(Integer,Integer)

Parameters: key (Integer), count (Integer)

Result: void / Unit.

During a call:

Internal implementation code; this is not a standalone script.

public void KeyPress(int key, int count) => KeyPress(key, count, 105);

UO.KeyPress(key, count, delay) — UO.KeyPress(Integer,Integer,Integer)

Parameters: key (Integer), count (Integer), delay (Integer)

Result: void / Unit.

During a call:

Internal implementation code; this is not a standalone script.

public void KeyPress(int key, int count, int delay)

        {

            while (count > 0)

            {

                bridge.KeyPress(key);

                bridge.Wait(delay);

                count--;

            }

        }

UO.LClick

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# signatures

void UO.LClick(object? x, object? y);

Synthesizes a single mouse click: left button.

Parameters

  • x — int X in ClassicUO window pixels, not world coordinate.
  • y — int Y in ClassicUO window pixels, not world coordinate.

Return value

void - no value. Call on a separate line; completion does not confirm the server's action.

Behavior

  • Bridge calls WarpMouse(x,y), updates Mouse.Position and SDL_WarpMouseInWindow, then MouseButton down/up once. There is no pause between double clicks.
  • Requires an open ClassicUO graphics window with input focus; otherwise RequireGameInput throws InvalidOperationException. user32 mouse_event is available on Windows. The button/object under the dot depends on the current interface.

Standalone C# scripts

Each example can be saved as a separate file .csx and run in IDE. The UO object and wait functions provide the host of the current game session. Replace demo serial names, coordinates and addresses with your own.

Simple example

Run this code as a separate .csx file. Arguments appear directly in the call; replace demonstration names, serials and addresses with your own.

The command is a separate statement. The message before it marks the start of the call; it does not confirm a server action.

UO.Print("Calling UO.LClick");
UO.LClick(100, 100);

1. Direct call - direct script

Parameters and execution flow:

  • Synthesizes a single mouse click: left button.
UO.LClick(100, 100);

2. Explicit option - script function

Parameters and execution flow:

  • Bridge calls WarpMouse(x,y), updates Mouse.Position and SDL_WarpMouseInWindow, then MouseButton down/up once. There is no pause between double clicks.
return  RunScenario();
 object? RunScenario()
{
    var x = 120;
    var y = 140;
    UO.LClick(x, y);
    return null;
}

3. Full Helper Function - Script Class

Parameters and execution flow:

  • Requires an open ClassicUO graphics window with input focus; otherwise RequireGameInput throws InvalidOperationException. user32 mouse_event is available on Windows. The button/object under the dot depends on the current interface.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        ClickAt(100, 100);
        return null;
    }

    void ClickAt(dynamic x, dynamic y)
    {
        UO.LClick(x, y);
    }
}

Command implementation

C# is case sensitive. Use the exact UO name. Compare numeric flags with 0; use bool only where the signature returns bool.

UO.LClick(x, y) — UO.LClick(Integer,Integer)

Parameters: x (Integer), y (Integer)

Result: void / Unit.

During a call:

Internal implementation code; this is not a standalone script.

public void LClick(int x, int y) => bridge.LClick(x, y);

UO.LDblClick

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# signatures

void UO.LDblClick(object? x, object? y);

Synthesizes a double mouse click: left button.

Parameters

  • x — int X in ClassicUO window pixels, not world coordinate.
  • y — int Y in ClassicUO window pixels, not world coordinate.

Return value

void - no value. Call on a separate line; completion does not confirm the server's action.

Behavior

  • Bridge calls WarpMouse(x,y), updates Mouse.Position and SDL_WarpMouseInWindow, then MouseButton down/up twice. There is no pause between double clicks.
  • Requires an open ClassicUO graphics window with input focus; otherwise RequireGameInput throws InvalidOperationException. user32 mouse_event is available on Windows. The button/object under the dot depends on the current interface.

Standalone C# scripts

Each example can be saved as a separate file .csx and run in IDE. The UO object and wait functions provide the host of the current game session. Replace demo serial names, coordinates and addresses with your own.

Simple example

Run this code as a separate .csx file. Arguments appear directly in the call; replace demonstration names, serials and addresses with your own.

The command is a separate statement. The message before it marks the start of the call; it does not confirm a server action.

UO.Print("Calling UO.LDblClick");
UO.LDblClick(100, 100);

1. Direct call - direct script

Parameters and execution flow:

  • Synthesizes a double mouse click: left button.
UO.LDblClick(100, 100);

2. Explicit option - script function

Parameters and execution flow:

  • Bridge calls WarpMouse(x,y), updates Mouse.Position and SDL_WarpMouseInWindow, then MouseButton down/up twice. There is no pause between double clicks.
return  RunScenario();
 object? RunScenario()
{
    var x = 120;
    var y = 140;
    UO.LDblClick(x, y);
    return null;
}

3. Full Helper Function - Script Class

Parameters and execution flow:

  • Requires an open ClassicUO graphics window with input focus; otherwise RequireGameInput throws InvalidOperationException. user32 mouse_event is available on Windows. The button/object under the dot depends on the current interface.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        ClickAt(100, 100);
        return null;
    }

    void ClickAt(dynamic x, dynamic y)
    {
        UO.LDblClick(x, y);
    }
}

Command implementation

C# is case sensitive. Use the exact UO name. Compare numeric flags with 0; use bool only where the signature returns bool.

UO.LDblClick(x, y) — UO.LDblClick(Integer,Integer)

Parameters: x (Integer), y (Integer)

Result: void / Unit.

During a call:

Internal implementation code; this is not a standalone script.

public void LDblClick(int x, int y) => bridge.LDblClick(x, y);

UO.Press

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# signatures

void UO.Press(object? key);
void UO.Press(object? key, object? count);
void UO.Press(object? key, object? count, object? delay);

Synthesizes one or more virtual-key presses.

Parameters

  • key - int virtual-key Windows, converted to byte. It is not a character string, nor is it a ID target.
  • count — Optional number of repetitions, default 1. 0/negative - no pressing or waiting.
  • delay - Optional pause of milliseconds after each press, including the last one; default is 105. Passed bridge.Wait without further restriction by this function.

Return value

void - no value. Call on a separate line; completion does not confirm the server's action.

Behavior

  • Press forwards all forms to KeyPress. KeyPress executes a loop count>0: bridge.KeyPress(key), bridge.Wait(delay), count--. Bridge sends user32 keybd_event down/up.
  • Requires open Graphics ClassicUO with input focus; otherwise RequireGameInput throws an error. The click processes the current interface/macro, the result of the server command is not returned.

Standalone C# scripts

Each example can be saved as a separate file .csx and run in IDE. The UO object and wait functions provide the host of the current game session. Replace demo serial names, coordinates and addresses with your own.

Simple example

Run this code as a separate .csx file. Arguments appear directly in the call; replace demonstration names, serials and addresses with your own.

The command is a separate statement. The message before it marks the start of the call; it does not confirm a server action.

UO.Print("Calling UO.Press");
UO.Press(0x70);

1. Direct call - direct script

Parameters and execution flow:

  • Synthesizes one or more virtual-key presses.
UO.Press(0x70);

2. Explicit option - script function

Parameters and execution flow:

  • Press forwards all forms to KeyPress. KeyPress executes a loop count>0: bridge.KeyPress(key), bridge.Wait(delay), count--. Bridge sends user32 keybd_event down/up.
return  RunScenario();
 object? RunScenario()
{
    UO.Press(0x70, 2, 250);
    return null;
}

3. Full Helper Function - Script Class

Parameters and execution flow:

  • Requires open Graphics ClassicUO with input focus; otherwise RequireGameInput throws an error. The click processes the current interface/macro, the result of the server command is not returned.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        UO.Press(0x70, 0);
        UO.Print("Zero count sends no key");
        return null;
    }
}

Command implementation

C# is case sensitive. Use the exact UO name. Compare numeric flags with 0; use bool only where the signature returns bool.

UO.Press(key) — UO.Press(Integer)

Parameters: key (Integer)

Result: void / Unit.

During a call:

Internal implementation code; this is not a standalone script.

public void Press(int key) => KeyPress(key);

UO.Press(key, count) — UO.Press(Integer,Integer)

Parameters: key (Integer), count (Integer)

Result: void / Unit.

During a call:

Internal implementation code; this is not a standalone script.

public void Press(int key, int count) => KeyPress(key, count);

UO.Press(key, count, delay) — UO.Press(Integer,Integer,Integer)

Parameters: key (Integer), count (Integer), delay (Integer)

Result: void / Unit.

During a call:

Internal implementation code; this is not a standalone script.

public void Press(int key, int count, int delay) => KeyPress(key, count, delay);

UO.RClick

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# signatures

void UO.RClick(object? x, object? y);

Synthesizes a single mouse click: right button.

Parameters

  • x — int X in ClassicUO window pixels, not world coordinate.
  • y — int Y in ClassicUO window pixels, not world coordinate.

Return value

void - no value. Call on a separate line; completion does not confirm the server's action.

Behavior

  • Bridge calls WarpMouse(x,y), updates Mouse.Position and SDL_WarpMouseInWindow, then MouseButton down/up once. There is no pause between double clicks.
  • Requires an open ClassicUO graphics window with input focus; otherwise RequireGameInput throws InvalidOperationException. user32 mouse_event is available on Windows. The button/object under the dot depends on the current interface.

Standalone C# scripts

Each example can be saved as a separate file .csx and run in IDE. The UO object and wait functions provide the host of the current game session. Replace demo serial names, coordinates and addresses with your own.

Simple example

Run this code as a separate .csx file. Arguments appear directly in the call; replace demonstration names, serials and addresses with your own.

The command is a separate statement. The message before it marks the start of the call; it does not confirm a server action.

UO.Print("Calling UO.RClick");
UO.RClick(100, 100);

1. Direct call - direct script

Parameters and execution flow:

  • Synthesizes a single mouse click: right button.
UO.RClick(100, 100);

2. Explicit option - script function

Parameters and execution flow:

  • Bridge calls WarpMouse(x,y), updates Mouse.Position and SDL_WarpMouseInWindow, then MouseButton down/up once. There is no pause between double clicks.
return  RunScenario();
 object? RunScenario()
{
    var x = 120;
    var y = 140;
    UO.RClick(x, y);
    return null;
}

3. Full Helper Function - Script Class

Parameters and execution flow:

  • Requires an open ClassicUO graphics window with input focus; otherwise RequireGameInput throws InvalidOperationException. user32 mouse_event is available on Windows. The button/object under the dot depends on the current interface.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        ClickAt(100, 100);
        return null;
    }

    void ClickAt(dynamic x, dynamic y)
    {
        UO.RClick(x, y);
    }
}

Command implementation

C# is case sensitive. Use the exact UO name. Compare numeric flags with 0; use bool only where the signature returns bool.

UO.RClick(x, y) — UO.RClick(Integer,Integer)

Parameters: x (Integer), y (Integer)

Result: void / Unit.

During a call:

Internal implementation code; this is not a standalone script.

public void RClick(int x, int y) => bridge.RClick(x, y);

UO.RDblClick

Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어

C# signatures

void UO.RDblClick(object? x, object? y);

Synthesizes a double mouse click: right button.

Parameters

  • x — int X in ClassicUO window pixels, not world coordinate.
  • y — int Y in ClassicUO window pixels, not world coordinate.

Return value

void - no value. Call on a separate line; completion does not confirm the server's action.

Behavior

  • Bridge calls WarpMouse(x,y), updates Mouse.Position and SDL_WarpMouseInWindow, then MouseButton down/up twice. There is no pause between double clicks.
  • Requires an open ClassicUO graphics window with input focus; otherwise RequireGameInput throws InvalidOperationException. user32 mouse_event is available on Windows. The button/object under the dot depends on the current interface.

Standalone C# scripts

Each example can be saved as a separate file .csx and run in IDE. The UO object and wait functions provide the host of the current game session. Replace demo serial names, coordinates and addresses with your own.

Simple example

Run this code as a separate .csx file. Arguments appear directly in the call; replace demonstration names, serials and addresses with your own.

The command is a separate statement. The message before it marks the start of the call; it does not confirm a server action.

UO.Print("Calling UO.RDblClick");
UO.RDblClick(100, 100);

1. Direct call - direct script

Parameters and execution flow:

  • Synthesizes a double mouse click: right button.
UO.RDblClick(100, 100);

2. Explicit option - script function

Parameters and execution flow:

  • Bridge calls WarpMouse(x,y), updates Mouse.Position and SDL_WarpMouseInWindow, then MouseButton down/up twice. There is no pause between double clicks.
return  RunScenario();
 object? RunScenario()
{
    var x = 120;
    var y = 140;
    UO.RDblClick(x, y);
    return null;
}

3. Full Helper Function - Script Class

Parameters and execution flow:

  • Requires an open ClassicUO graphics window with input focus; otherwise RequireGameInput throws InvalidOperationException. user32 mouse_event is available on Windows. The button/object under the dot depends on the current interface.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        ClickAt(100, 100);
        return null;
    }

    void ClickAt(dynamic x, dynamic y)
    {
        UO.RDblClick(x, y);
    }
}

Command implementation

C# is case sensitive. Use the exact UO name. Compare numeric flags with 0; use bool only where the signature returns bool.

UO.RDblClick(x, y) — UO.RDblClick(Integer,Integer)

Parameters: x (Integer), y (Integer)

Result: void / Unit.

During a call:

Internal implementation code; this is not a standalone script.

public void RDblClick(int x, int y) => bridge.RDblClick(x, y);

ClassicUO — Bad Newbie & C# Scripts IDE

ClassicUO — Bad Newbie & C# Scripts IDE

Clone this wiki locally