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

Mouse e tastiera

Home · C# · IDE · UO API · A–Z · Esempi · Lingue

Inserimento tramite mouse e tastiera. Le coordinate dello schermo, le celle del mondo e le coordinate all'interno di un gump hanno significati diversi.

Sezioni

Argomento	Comandi e spiegazioni
Click	UO.Click
LClick	UO.LClick
RClick	UO.RClick
DoubleClick	UO.LDblClick · UO.RDblClick
KeyPress	UO.KeyPress
Press	UO.Press

Tutti i comandi del tema

Ingresso

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

Esempi sull'argomento

Ogni carta comando ha diversi scenari indipendenti: codice diretto, funzioni e classi. Di seguito sono selezionati brevi scenari; restrizioni e un'analisi completa sono nelle carte.

UO.LClick

Parametri, risultato e tutti gli scenari

UO.LClick(100, 100);

UO.KeyPress

Parametri, risultato e tutti gli scenari

UO.KeyPress(0x70);

Riferimento completo dei comandi

UO.Click

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

Firme C#

void UO.Click(object? name);

Invia un singolo clic su un oggetto tramite GameActions.SingleClick.

Parametri

name — Numero seriale dell'oggetto o nome supportato di self/backpack/lasttarget/oggetto salvato; le stringhe numeriche e le stringhe 0x vengono risolte dal runtime.

Valore restituito

void: nessun valore restituito.

Comportamento

Click risolve il collegamento tramite ObjectChecked. ClickOnObject usa prima Arg per serial e chiama Click(int). Questa è una richiesta per la firma/informazione dell'oggetto, non DoubleClick o l'utilizzo dell'oggetto. La risposta del server arriva in modo asincrono.

Script C# autonomi

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

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

1. Fare clic su carattere - sceneggiatura diretta

Parametri e flusso di esecuzione:

Un singolo clic viene inviato a self.

UO.Click("self");

2. Fare clic sull'ultimo target: funzione script

Parametri e flusso di esecuzione:

Prima dell'invio viene verificata l'esistenza locale della destinazione.

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. Faranno clic sullo zaino - lezione di script

Parametri e flusso di esecuzione:

Un singolo clic su uno zaino non lo apre come farebbe doppio clic su di esso.

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;
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

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

Parametri: name (Any)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Click.
InjectionScript.Runtime.InjectionApiUO.ObjectChecked: ObjectChecked(name, id => Click(id)).
InjectionScript.Runtime.InjectionApiUO.Click: Click(id).

Codice interno di implementazione; non è uno script autonomo.

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

UO.KeyPress

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

Firme C#

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

Sintetizza una o più pressioni di tasti virtuali.

Parametri

key - int chiave virtuale Windows, convertito in byte. Non è una stringa di caratteri, né è un target ID.
count — Numero opzionale di ripetizioni, predefinito 1. 0/negativo - nessuna pressione o attesa.
delay - Pausa opzionale di millisecondi dopo ogni pressione, inclusa l'ultima; l'impostazione predefinita è 105. Trasmesso tramite bridge.Wait senza ulteriori restrizioni da parte di questa funzione.

Valore restituito

void - nessun valore. Chiama su una linea separata; il completamento non conferma l'azione del server.

Comportamento

Press inoltra tutti i moduli a KeyPress. KeyPress esegue un conteggio del loop>0: bridge.KeyPress(tasto), bridge.Wait(ritardo), conteggio--. Bridge invia user32 keybd_event giù/su.
Richiede Graphics ClassicUO aperta con focus sull'input; altrimenti RequireGameInput genera un errore. Il clic elabora l'interfaccia/macro corrente, il risultato del comando del server non viene restituito.

Script C# autonomi

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

Sintetizza una o più pressioni di tasti virtuali.

UO.KeyPress(0x70);

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

Press inoltra tutti i moduli a KeyPress. KeyPress esegue un conteggio del loop>0: bridge.KeyPress(tasto), bridge.Wait(ritardo), conteggio--. Bridge invia user32 keybd_event giù/su.

return  RunScenario();
 object? RunScenario()
{
    UO.KeyPress(0x70, 2, 250);
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

Richiede Graphics ClassicUO aperta con focus sull'input; altrimenti RequireGameInput genera un errore. Il clic elabora l'interfaccia/macro corrente, il risultato del comando del server non viene restituito.

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;
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

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

Parametri: key (Integer)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.KeyPress.
InjectionScript.Runtime.InjectionApiUO.KeyPress: KeyPress(key, 1).

Codice interno di implementazione; non è uno script autonomo.

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

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

Parametri: key (Integer), count (Integer)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.KeyPress.
InjectionScript.Runtime.InjectionApiUO.KeyPress: KeyPress(key, count, 105).

Codice interno di implementazione; non è uno script autonomo.

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

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

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

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.KeyPress.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.KeyPress: bridge.KeyPress(key).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Wait: bridge.Wait(delay).

Codice interno di implementazione; non è uno script autonomo.

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 · 繁體中文 · 日本語 · 한국어

Firme C#

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

Sintetizza un singolo clic del mouse: pulsante sinistro.

Parametri

x - int X nei pixel della finestra ClassicUO, non nelle coordinate globali.
y - int Y nei pixel della finestra ClassicUO, non nelle coordinate globali.

Valore restituito

void - nessun valore. Chiama su una linea separata; il completamento non conferma l'azione del server.

Comportamento

Il bridge chiama WarpMouse(x,y), aggiorna Mouse.Position e SDL_WarpMouseInWindow, quindi MouseButton giù/su una volta. Non c'è pausa tra i doppi clic.
Richiede una finestra grafica ClassicUO aperta con focus sull'input; altrimenti RequireGameInput lancia InvalidOperationException. user32 mouse_event è disponibile su Windows. Il pulsante/oggetto sotto il punto dipende dall'interfaccia corrente.

Script C# autonomi

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

Sintetizza un singolo clic del mouse: pulsante sinistro.

UO.LClick(100, 100);

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

Il bridge chiama WarpMouse(x,y), aggiorna Mouse.Position e SDL_WarpMouseInWindow, quindi MouseButton giù/su una volta. Non c'è pausa tra i doppi clic.

return  RunScenario();
 object? RunScenario()
{
    var x = 120;
    var y = 140;
    UO.LClick(x, y);
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

Richiede una finestra grafica ClassicUO aperta con focus sull'input; altrimenti RequireGameInput lancia InvalidOperationException. user32 mouse_event è disponibile su Windows. Il pulsante/oggetto sotto il punto dipende dall'interfaccia corrente.

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);
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

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

Parametri: x (Integer), y (Integer)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.LClick.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.LClick: bridge.LClick(x, y).

Codice interno di implementazione; non è uno script autonomo.

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

UO.LDblClick

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

Firme C#

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

Sintetizza un doppio clic del mouse: pulsante sinistro.

Parametri

x - int X nei pixel della finestra ClassicUO, non nelle coordinate globali.
y - int Y nei pixel della finestra ClassicUO, non nelle coordinate globali.

Valore restituito

void - nessun valore. Chiama su una linea separata; il completamento non conferma l'azione del server.

Comportamento

Il bridge chiama WarpMouse(x,y), aggiorna Mouse.Position e SDL_WarpMouseInWindow, quindi MouseButton giù/su due volte. Non c'è pausa tra i doppi clic.
Richiede una finestra grafica ClassicUO aperta con focus sull'input; altrimenti RequireGameInput lancia InvalidOperationException. user32 mouse_event è disponibile su Windows. Il pulsante/oggetto sotto il punto dipende dall'interfaccia corrente.

Script C# autonomi

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

Sintetizza un doppio clic del mouse: pulsante sinistro.

UO.LDblClick(100, 100);

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

Il bridge chiama WarpMouse(x,y), aggiorna Mouse.Position e SDL_WarpMouseInWindow, quindi MouseButton giù/su due volte. Non c'è pausa tra i doppi clic.

return  RunScenario();
 object? RunScenario()
{
    var x = 120;
    var y = 140;
    UO.LDblClick(x, y);
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

Richiede una finestra grafica ClassicUO aperta con focus sull'input; altrimenti RequireGameInput lancia InvalidOperationException. user32 mouse_event è disponibile su Windows. Il pulsante/oggetto sotto il punto dipende dall'interfaccia corrente.

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);
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

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

Parametri: x (Integer), y (Integer)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.LDblClick.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.LDblClick: bridge.LDblClick(x, y).

Codice interno di implementazione; non è uno script autonomo.

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

UO.Press

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

Firme C#

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

Sintetizza una o più pressioni di tasti virtuali.

Parametri

key - int chiave virtuale Windows, convertito in byte. Non è una stringa di caratteri, né è un target ID.
count — Numero opzionale di ripetizioni, predefinito 1. 0/negativo - nessuna pressione o attesa.
delay - Pausa opzionale di millisecondi dopo ogni pressione, inclusa l'ultima; l'impostazione predefinita è 105. Trasmesso tramite bridge.Wait senza ulteriori restrizioni da parte di questa funzione.

Valore restituito

void - nessun valore. Chiama su una linea separata; il completamento non conferma l'azione del server.

Comportamento

Press inoltra tutti i moduli a KeyPress. KeyPress esegue un conteggio del loop>0: bridge.KeyPress(tasto), bridge.Wait(ritardo), conteggio--. Bridge invia user32 keybd_event giù/su.
Richiede Graphics ClassicUO aperta con focus sull'input; altrimenti RequireGameInput genera un errore. Il clic elabora l'interfaccia/macro corrente, il risultato del comando del server non viene restituito.

Script C# autonomi

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

Sintetizza una o più pressioni di tasti virtuali.

UO.Press(0x70);

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

Press inoltra tutti i moduli a KeyPress. KeyPress esegue un conteggio del loop>0: bridge.KeyPress(tasto), bridge.Wait(ritardo), conteggio--. Bridge invia user32 keybd_event giù/su.

return  RunScenario();
 object? RunScenario()
{
    UO.Press(0x70, 2, 250);
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

Richiede Graphics ClassicUO aperta con focus sull'input; altrimenti RequireGameInput genera un errore. Il clic elabora l'interfaccia/macro corrente, il risultato del comando del server non viene restituito.

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;
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

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

Parametri: key (Integer)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Press.
InjectionScript.Runtime.InjectionApiUO.KeyPress: KeyPress(key).

Codice interno di implementazione; non è uno script autonomo.

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

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

Parametri: key (Integer), count (Integer)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Press.
InjectionScript.Runtime.InjectionApiUO.KeyPress: KeyPress(key, count).

Codice interno di implementazione; non è uno script autonomo.

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

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

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

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Press.
InjectionScript.Runtime.InjectionApiUO.KeyPress: KeyPress(key, count, delay).

Codice interno di implementazione; non è uno script autonomo.

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

UO.RClick

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

Firme C#

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

Sintetizza un singolo clic del mouse: pulsante destro.

Parametri

x - int X nei pixel della finestra ClassicUO, non nelle coordinate globali.
y - int Y nei pixel della finestra ClassicUO, non nelle coordinate globali.

Valore restituito

void - nessun valore. Chiama su una linea separata; il completamento non conferma l'azione del server.

Comportamento

Il bridge chiama WarpMouse(x,y), aggiorna Mouse.Position e SDL_WarpMouseInWindow, quindi MouseButton giù/su una volta. Non c'è pausa tra i doppi clic.
Richiede una finestra grafica ClassicUO aperta con focus sull'input; altrimenti RequireGameInput lancia InvalidOperationException. user32 mouse_event è disponibile su Windows. Il pulsante/oggetto sotto il punto dipende dall'interfaccia corrente.

Script C# autonomi

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

Sintetizza un singolo clic del mouse: pulsante destro.

UO.RClick(100, 100);

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

Il bridge chiama WarpMouse(x,y), aggiorna Mouse.Position e SDL_WarpMouseInWindow, quindi MouseButton giù/su una volta. Non c'è pausa tra i doppi clic.

return  RunScenario();
 object? RunScenario()
{
    var x = 120;
    var y = 140;
    UO.RClick(x, y);
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

Richiede una finestra grafica ClassicUO aperta con focus sull'input; altrimenti RequireGameInput lancia InvalidOperationException. user32 mouse_event è disponibile su Windows. Il pulsante/oggetto sotto il punto dipende dall'interfaccia corrente.

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);
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

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

Parametri: x (Integer), y (Integer)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.RClick.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.RClick: bridge.RClick(x, y).

Codice interno di implementazione; non è uno script autonomo.

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

UO.RDblClick

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

Firme C#

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

Sintetizza un doppio clic del mouse: pulsante destro.

Parametri

x - int X nei pixel della finestra ClassicUO, non nelle coordinate globali.
y - int Y nei pixel della finestra ClassicUO, non nelle coordinate globali.

Valore restituito

void - nessun valore. Chiama su una linea separata; il completamento non conferma l'azione del server.

Comportamento

Il bridge chiama WarpMouse(x,y), aggiorna Mouse.Position e SDL_WarpMouseInWindow, quindi MouseButton giù/su due volte. Non c'è pausa tra i doppi clic.
Richiede una finestra grafica ClassicUO aperta con focus sull'input; altrimenti RequireGameInput lancia InvalidOperationException. user32 mouse_event è disponibile su Windows. Il pulsante/oggetto sotto il punto dipende dall'interfaccia corrente.

Script C# autonomi

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

Sintetizza un doppio clic del mouse: pulsante destro.

UO.RDblClick(100, 100);

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

Il bridge chiama WarpMouse(x,y), aggiorna Mouse.Position e SDL_WarpMouseInWindow, quindi MouseButton giù/su due volte. Non c'è pausa tra i doppi clic.

return  RunScenario();
 object? RunScenario()
{
    var x = 120;
    var y = 140;
    UO.RDblClick(x, y);
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

Richiede una finestra grafica ClassicUO aperta con focus sull'input; altrimenti RequireGameInput lancia InvalidOperationException. user32 mouse_event è disponibile su Windows. Il pulsante/oggetto sotto il punto dipende dall'interfaccia corrente.

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);
    }
}

Implementazione del comando

C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

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

Parametri: x (Integer), y (Integer)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.RDblClick.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.RDblClick: bridge.RDblClick(x, y).

Codice interno di implementazione; non è uno script autonomo.

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

IT UO Topic mouse keyboard - LIHACHTETAN/ClassicUO-Bad-Newbie-CSharp-Scripts-IDE GitHub Wiki

Mouse e tastiera

Sezioni

Tutti i comandi del tema

Ingresso

Esempi sull'argomento

UO.LClick

UO.KeyPress

Riferimento completo dei comandi

UO.Click

Firme C#

Parametri

Valore restituito

Comportamento

Script C# autonomi

Esempio semplice

1. Fare clic su carattere - sceneggiatura diretta

2. Fare clic sull'ultimo target: funzione script

3. Faranno clic sullo zaino - lezione di script

Implementazione del comando

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

UO.KeyPress

Firme C#

Parametri

Valore restituito

Comportamento

Script C# autonomi

Esempio semplice

1. Chiamata diretta - sceneggiatura diretta

2. Opzione esplicita: funzione dello script

3. Funzione di supporto completa: classe di script

Implementazione del comando

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

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

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

UO.LClick

Firme C#

Parametri

Valore restituito

Comportamento

Script C# autonomi

Esempio semplice

1. Chiamata diretta - sceneggiatura diretta

2. Opzione esplicita: funzione dello script

3. Funzione di supporto completa: classe di script

Implementazione del comando

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

UO.LDblClick

Firme C#

Parametri

Valore restituito

Comportamento

Script C# autonomi

Esempio semplice

1. Chiamata diretta - sceneggiatura diretta

2. Opzione esplicita: funzione dello script

3. Funzione di supporto completa: classe di script

Implementazione del comando

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

UO.Press

Firme C#

Parametri

Valore restituito

Comportamento

Script C# autonomi

Esempio semplice

1. Chiamata diretta - sceneggiatura diretta

2. Opzione esplicita: funzione dello script

3. Funzione di supporto completa: classe di script

Implementazione del comando

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

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

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

UO.RClick

Firme C#

Parametri

Valore restituito

Comportamento

Script C# autonomi

Esempio semplice

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

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

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

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

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

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

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

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

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

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

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

⚠️ GitHub.com Fallback ⚠️