Skip to content

IT UO Topic gumps

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

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

Finestre Gump

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

Lettura delle finestre del server e invio di risposte: pulsanti, caselle di controllo, pulsanti di opzione e campi. La finestra ID, il proprietario serial e l'indice della finestra aperta non sono intercambiabili.

Sezioni

Argomento Comandi e spiegazioni
GetGump UO.GetGump
GetGumpInfo UO.GetGumpInfo
Gump ID / Serial UO.GetGumpID · UO.GetGumpSerial
Text Lines UO.GetGumpTextLines · UO.GetGumpFullLines · UO.GetGumpShortLines
Buttons UO.GetGumpButtonsDescription · UO.NumGumpButton
CheckBox UO.NumGumpCheckBox · UO.GumpAutoCheckBox
RadioButton UO.NumGumpRadiobutton · UO.GumpAutoRadiobutton
TextEntry UO.NumGumpTextEntry · UO.GumpAutoTextEntry
WaitGump UO.WaitGump
SelectGump UO.SelectGump
SendGumpSelect UO.SendGumpSelect
Ignore Gumps UO.AddGumpIgnoreByID · UO.AddGumpIgnoreBySerial · UO.ClearGumpsIgnore
Close Gump UO.IsGumpCanBeClosed · UO.CloseClientGump · UO.CancelGump

Tutti i comandi del tema

Informazioni Gump

UO.GetGump · UO.GetGumpID · UO.GetGumpSerial · UO.GetGumpCount · UO.GetGumpsCount · UO.GetGumpInfo · UO.GetGumpButtonsDescription · UO.GetGumpFullLines · UO.GetGumpShortLines · UO.GetGumpTextLines · UO.GumpObject · UO.LastGump · UO.IsGump · UO.GumpExists · UO.IsGumpCanBeClosed

Risposte

UO.NumGumpButton · UO.NumGumpCheckBox · UO.NumGumpRadiobutton · UO.NumGumpTextEntry · UO.GumpAutoCheckBox · UO.GumpAutoRadiobutton · UO.GumpAutoTextEntry · UO.WaitGump · UO.WaitGumpCheck · UO.WaitGumpEntry · UO.SelectGump · UO.SendGumpSelect · UO.SetGump

Ignore / Chiudi

UO.AddGumpIgnoreByID · UO.AddGumpIgnoreBySerial · UO.ClearGumpsIgnore · UO.CancelGump · UO.CloseClientGump

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.GetGumpInfo

Parametri, risultato e tutti gli scenari

var info = UO.GetGumpInfo(0);
if (Truth(ArrayLength(info) == 5))
{
    UO.Print("Serial=" + Hex(info[0]));
    UO.Print("GumpID=" + Hex(info[1]));
}

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
string Hex(object? value) => Convert.ToInt64(value).ToString("X");
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;

UO.WaitGump

Parametri, risultato e tutti gli scenari

UO.WaitGump(100);
UO.UseObject("0x40001234");

Riferimento completo dei comandi

UO.AddGumpIgnoreByID

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

Firme C#

void UO.AddGumpIgnoreByID(object? id);

Aggiunge il gump numerico ID all'elenco delle eccezioni locali utilizzato da UO.GetGumpInfo.

Parametri

  • id è un gump numerico ID che restituisce UO.GetGumpInfo.

Valore restituito

void. L'aggiunta di ID non chiude la finestra né conferma che il server l'ha elaborato.

Comportamento

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.AddGumpIgnoreByID");
UO.AddGumpIgnoreByID(123);

1. Elimina il gump con ID 123 dal risultato di UO.GetGumpInfo. - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Elimina il gump con ID 123 dal risultato di UO.GetGumpInfo.
UO.AddGumpIgnoreByID(123);

2. Memorizza ID in una variabile prima di lanciare l'eccezione. - funzione di script

Parametri e flusso di esecuzione:

  • Memorizza ID in una variabile prima di lanciare l'eccezione.
return  RunScenario();
 object? RunScenario()
{
    var ignoredId = 123;
    UO.AddGumpIgnoreByID(ignoredId);
    return null;
}

3. Aggiungi un po' di ID; ogni eccezione influisce su GetGumpInfo. - lezione di sceneggiatura

Parametri e flusso di esecuzione:

  • Aggiungi un po' di ID; ogni eccezione influisce su GetGumpInfo.
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.AddGumpIgnoreByID(123);
        UO.AddGumpIgnoreByID(456);
        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.AddGumpIgnoreByID(id) — UO.AddGumpIgnoreByID(Any)

Parametri: id (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "addgumpignorebyid": state.IgnoredGumpIds.Add(Arg(0)); return InjectionValue.Unit;

UO.AddGumpIgnoreBySerial

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

Firme C#

void UO.AddGumpIgnoreBySerial(object? serial);

Aggiunge il serial gump all'elenco delle eccezioni locali utilizzato da UO.GetGumpInfo.

Parametri

  • serial è un gump numerico serial che restituisce UO.GetGumpInfo.

Valore restituito

void. L'aggiunta di serial non chiude la finestra né conferma che il server l'ha elaborato.

Comportamento

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.AddGumpIgnoreBySerial");
UO.AddGumpIgnoreBySerial(1073741824);

1. Elimina il gump con serial 1073741824 dal risultato UO.GetGumpInfo. - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Elimina il gump con serial 1073741824 dal risultato UO.GetGumpInfo.
UO.AddGumpIgnoreBySerial(1073741824);

2. Passa serial dalla variabile. - funzione di script

Parametri e flusso di esecuzione:

  • Passa serial dalla variabile.
return  RunScenario();
 object? RunScenario()
{
    var ignoredSerial = 1073741824;
    UO.AddGumpIgnoreBySerial(ignoredSerial);
    return null;
}

3. Elimina due gump serial dall'output di GetGumpInfo. - lezione di sceneggiatura

Parametri e flusso di esecuzione:

  • Elimina due gump serial dall'output di GetGumpInfo.
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.AddGumpIgnoreBySerial(1073741824);
        UO.AddGumpIgnoreBySerial(1073741825);
        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.AddGumpIgnoreBySerial(serial) — UO.AddGumpIgnoreBySerial(Any)

Parametri: serial (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "addgumpignorebyserial": state.IgnoredGumpSerials.Add(Arg(0)); return InjectionValue.Unit;

UO.CancelGump

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

Firme C#

void UO.CancelGump();
void UO.CancelGump(object? gumpId);

Chiude il gump del server selezionato tramite un risolutore compatibile CloseSimpleGump.

Parametri

  • gumpId - Opzionale int/valore numerico. Il risolutore cerca prima un server/locale serial corrispondente, quindi l'indice Gump del server. Senza argomenti, viene passato -1 e viene selezionato l'ultimo gump.

Valore restituito

void: nessun valore restituito.

Comportamento

  • Un argomento denominato gumpId non garantisce di cercare solo ID. CloseGumpUnsafe per il server gump invia il pulsante 0, quindi elimina la finestra locale. Se il gump non viene trovato, non viene eseguita alcuna azione. Questo non è CancelMenu, né sta cancellando il WaitGump in sospeso.

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.CancelGump");
UO.CancelGump();

1. Chiudi l'ultimo gump - script diretto

Parametri e flusso di esecuzione:

  • Il modulo senza argomento seleziona l'ultimo server gump disponibile.
UO.CancelGump();

2. Chiudi il gump con la nota ID - funzione di script

Parametri e flusso di esecuzione:

  • Viene utilizzato l'effettivo ID del primo gump; l'elenco potrebbe cambiare tra una chiamata e l'altra.
return  RunScenario();
 object? RunScenario()
{
    var id = UO.GetGumpID(0);
    if (Truth(id != 0))
    {
        UO.CancelGump(id);
    }

    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. Ultimo indice esplicito: classe di script

Parametri e flusso di esecuzione:

  • Il valore -1 seleziona esplicitamente l'ultimo gump nel risolutore.
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.CancelGump(-1);
        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.CancelGump() — UO.CancelGump()

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "cancelgump": bridge.CloseSimpleGump(arguments.Length > 0 ? Arg(0) : -1); break;

UO.CancelGump(gumpId) — UO.CancelGump(Any)

Parametri: gumpId (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "cancelgump": bridge.CloseSimpleGump(arguments.Length > 0 ? Arg(0) : -1); break;

UO.ClearGumpsIgnore

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

Firme C#

void UO.ClearGumpsIgnore();

Cancella entrambi i set di runtime Gump ID e Gump serial ignorati.

Parametri

Non ci sono parametri.

Valore restituito

void: nessun valore restituito.

Comportamento

  • Non chiude le finestre. Dopo aver cancellato, GetGumpInfo può nuovamente restituire un'istantanea del gump precedentemente ignorato.

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.ClearGumpsIgnore");
UO.ClearGumpsIgnore();

1. Stato chiaro: sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Cancella entrambi i set di runtime Gump ID e Gump serial ignorati.
UO.ClearGumpsIgnore();

2. Cancella dopo l'installazione - funzione script

Parametri e flusso di esecuzione:

  • Rimuovi la regola di ignoranza aggiunta.
return  RunScenario();
 object? RunScenario()
{
    UO.AddGumpIgnoreByID(0x1234);
    UO.ClearGumpsIgnore();
    return null;
}

3. Rieliminazione: classe di script

Parametri e flusso di esecuzione:

  • La cancellazione di un set vuoto è accettabile e non crea una nuova impostazione.
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.ClearGumpsIgnore();
        UO.ClearGumpsIgnore();
        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.ClearGumpsIgnore() — UO.ClearGumpsIgnore()

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "cleargumpsignore":

                    state.IgnoredGumpIds.Clear(); state.IgnoredGumpSerials.Clear(); return InjectionValue.Unit;

UO.CloseClientGump

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

Firme C#

void UO.CloseClientGump(object? id);

Rimuove i gump del server locale il cui ServerSerial corrisponde al ID passato.

Parametri

  • id - int/numerico ID gump rispetto a ServerSerial. Questo non è un indice di elenco, né è locale serial.

Valore restituito

void: nessun valore restituito.

Comportamento

  • Scorre ServerGumpsUnsafe, crea uno snapshot di tutte le corrispondenze e chiama Dispose. Non invia il pulsante 0 o il risultato del modulo al server. Se non ci sono corrispondenze, non cambia nulla.

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.CloseClientGump");
UO.CloseClientGump(UO.GetGumpID(0));

1. Chiudi il primo Gump con ID - script diretto

Parametri e flusso di esecuzione:

  • GetGumpID fornisce il server ID; CloseClientGump rimuove le finestre locali corrispondenti.
if (Truth(UO.GetGumpsCount() > 0))
{
    var id = UO.GetGumpID(0);
    UO.CloseClientGump(id);
}

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

2. ID dalla variabile - funzione script

Parametri e flusso di esecuzione:

  • Specificare ID del gump del server desiderato; nessuna corrispondenza è accettabile.
return  RunScenario();
 object? RunScenario()
{
    var id = 0x12345678;
    UO.CloseClientGump(id);
    return null;
}

3. Richiudi: classe di script

Parametri e flusso di esecuzione:

  • Dopo il primo Dispose, la seconda chiusura solitamente non trova più la finestra.
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 id = UO.GetGumpID(0);
        if (Truth(id != 0))
        {
            UO.CloseClientGump(id);
            UO.CloseClientGump(id);
        }

        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.CloseClientGump(id) — UO.CloseClientGump(Any)

Parametri: id (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "closeclientgump": bridge.CloseClientGump(Arg(0)); return InjectionValue.Unit;

UO.GetGump

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

Firme C#

dynamic UO.GetGump(object? identifier);
dynamic UO.GetGump(object? gumpId, object? identifier);
dynamic UO.GetGump(object? gumpId, object? identifier, object? key);

Legge un campo del gump del server selezionato. Consente di impostare esplicitamente il selettore della finestra.

Parametri

  • gumpId - Opzionale prima int nelle forme (gumpId,identificatore) e (gumpId,identificatore,chiave). int o stringa numerica: cerca prima una corrispondenza esatta GumpID/serial, quindi l'indice con 0. -1 è il gump selezionato da questo script e, se non è presente, l'ultimo nell'elenco corrente. Altri negativi int mantengono 32-bit ID. Questo è un selettore, in contrapposizione al rigoroso GumpIndex in NumGump*.
  • identifier - string senza distinzione tra maiuscole e minuscole. Tutti i valori e i tipi di risultati supportati sono elencati nella sezione Resi. Il nome sconosciuto restituisce una stringa vuota.
  • key - Opzionale int, predefinito - 1. Indice con 0 per pulsante/testo/object/comando; questo non è il controllo ID. Un indice negativo e fuori dai limiti risulta in 0 per il pulsante o una stringa vuota per i campi di testo. Altri identificatori non utilizzano la chiave.

Valore restituito

Il tipo del risultato dipende dall'identificatore. int: buttonlen — numero di pulsanti regolari; button — ButtonID per chiave indice; textlen: numero di elementi di testo disponibili; injid: indice della finestra corrente; risposto — 0 (la cronologia delle risposte non viene memorizzata); inclient — 1 per una finestra live trovata, 0 se assente; objectcount: numero di controlli live, inclusi quelli nidificati. string: serial e gumpid - stringhe esadecimali 0xXXXXXXXX; text — testo dell'elemento nella chiave dell'indice; object — nome del tipo di controllo; comando — descrizione del controllo (tipo, pagina, ID, coordinate, dimensioni e campi supportati). Se non è presente alcuna finestra, gli identificatori numerici danno 0, gli identificatori di stringa danno una stringa vuota. injid=0 è anche un primo indice valido: 0 di per sé non dimostra l'assenza di una finestra. Questo non è Array o Pascal TGumpInfo.

Comportamento

  • Funziona con gump server attivi. Zaino, mappa, impostazioni e altre finestre locali non sono incluse in questo elenco. Una chiamata legge i dati nel thread del gioco; chiamate diverse possono visualizzare stati diversi dell'elenco.
  • SelectGump/InfoGump specifica la finestra selezionata solo nel runtime corrente. Se la finestra selezionata viene chiusa, viene utilizzato l'ultimo elemento dell'elenco corrente, che non è necessariamente l'elemento più recente nel tempo.
  • textlen/text fa riferimento ai controlli di testo disponibili, non al pool di stringhe originale del pacchetto server. object/command si riferisce all'intero albero dei controlli live. Non è possibile mischiare indici di elenchi diversi.
  • Ogni chiamata legge lo stato corrente separatamente. Per serial, GumpID ed elenchi corrispondenti, utilizzare GetGumpInfo.

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 risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

object? result = UO.GetGump("gumpid");
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

1. Leggi ID della finestra selezionata - script diretto

Parametri e flusso di esecuzione:

  • gumpid e serial restituiscono stringhe già formattate in esadecimale; non è necessario alcun esagono aggiuntivo. Le righe vuote indicano che non è presente alcuna finestra durante la lettura.
var id = UO.GetGump("gumpid");
var serial = UO.GetGump("serial");
UO.Print(id + " / " + serial);

2. Enumerare ButtonID - Funzione script

Parametri e flusso di esecuzione:

  • buttonlen: numero di pulsanti; i è l'indice della riga da 0 a count-1. pulsante - ID per la risposta, non grafica o indice. Quando cambi finestra, rileggi l'elenco.
return  RunScenario();
 object? RunScenario()
{
    var count = UO.GetGump("buttonlen");
    var i = 0;
    while (Truth(i < count))
    {
        var button = UO.GetGump("button", i);
        UO.Print(Convert.ToString(button));
        i = i + 1;
    }

    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. Leggi il testo dopo la selezione - classe di script

Parametri e flusso di esecuzione:

  • 0x12345678 è un esempio di GumpID/serial, sostituisci ID con la forma desiderata. text with key=0 legge il primo controllo di testo disponibile; questo è un elenco diverso dal pulsante.
  • SelectGump segnala l'assenza della finestra specificata, ma non blocca la successiva lettura: verificare separatamente il gumpid restituito se necessario.
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.SelectGump(0x12345678);
        if (Truth(UO.GetGump("inclient")))
        {
            var count = UO.GetGump("textlen");
            if (Truth(count > 0))
            {
                UO.Print(UO.GetGump("text", 0));
            }
        }

        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.GetGump(identifier) — UO.GetGump(String)

Parametri: identifier (String)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public InjectionValue GetGump(string identifier) => LastGump(identifier, -1);

UO.GetGump(gumpId, identifier) — UO.GetGump(Integer,String)

Parametri: gumpId (Integer/String), identifier (String/Integer)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public InjectionValue GetGump(int gumpId, string identifier) => GetGump(gumpId, identifier, -1);

UO.GetGump(gumpId, identifier) — UO.GetGump(String,Integer)

Parametri: gumpId (Integer/String), identifier (String/Integer)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public InjectionValue GetGump(string identifier, int key) => LastGump(identifier, key);

UO.GetGump(gumpId, identifier, key) — UO.GetGump(Integer,String,Integer)

Parametri: gumpId (Integer), identifier (String), key (Integer)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public InjectionValue GetGump(int gumpId, string identifier, int key)

            => ConvertGumpValue(identifier, bridge.GetGumpValue(gumpId, identifier, key));

UO.GetGumpButtonsDescription

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

Firme C#

dynamic UO.GetGumpButtonsDescription(object? gumpIndex);

Restituisce le descrizioni dei normali pulsanti gump del server.

Parametri

  • gumpIndex — Obbligatorio int — indice del server attivo gump, da 0 a GetGumpsCount()-1. Questo non è GumpID/serial. Il numero negativo e l'indice fuori dall'elenco non sono validi. L'apertura, la chiusura e il riordino delle finestre possono modificare l'indice; controlla GetGumpID/GetGumpSerial prima di agire.

Valore restituito

Array - descrizioni dei pulsanti regolari. [] - indice non valido o nessun elemento corrispondente. L'indice della riga inizia con 0; non è un controllo ID.

Comportamento

  • Funziona con gump server attivi. Zaino, mappa, impostazioni e altre finestre locali non sono incluse in questo elenco. Una chiamata legge i dati nel thread del gioco; chiamate diverse possono visualizzare stati diversi dell'elenco.
  • Ogni riga contiene ButtonID, azione, toPage e grafica. I pulsanti di opzione non sono normali pulsanti di risposta.
  • Quando SilentMode=0 anche il risultato non vuoto viene aggiunto alla finestra di testo e la apre. SetSilentMode(1) lascia solo la restituzione dell'array.

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 risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

object? result = UO.GetGumpButtonsDescription(0);
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

1. Leggi la prima riga: script diretto

Parametri e flusso di esecuzione:

  • 0 — indice della finestra. ArrayLength verifica la presenza di una linea prima di chiamare le linee[0].
var lines = UO.GetGumpButtonsDescription(0);
if (Truth(ArrayLength(lines) > 0))
{
    UO.Print(lines[0]);
}

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;

2. Attraversa tutte le linee senza finestra automatica - funzione script

Parametri e flusso di esecuzione:

  • SetSilentMode(1) disabilita la finestra di testo aggiuntiva. La Print esplicita nell'esempio stampa ancora le stringhe.
  • i è l'indice dell'array; Prendere ID del pulsante/interruttore desiderato dalla descrizione corrispondente.
return  RunScenario();
 object? RunScenario()
{
    UO.SetSilentMode(1);
    var lines = UO.GetGumpButtonsDescription(0);
    var i = 0;
    while (Truth(i < ArrayLength(lines)))
    {
        UO.Print(lines[i]);
        i = i + 1;
    }

    return null;
}

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;

3. Leggi i dati dell'ultima finestra del server aperta - Classe script

Parametri e flusso di esecuzione:

  • Il conteggio viene convertito nell'indice dell'ultima finestra. I dati vengono letti dal server gump caricato; le finestre locali non sono incluse qui.
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()
    {
        int count = UO.GetGumpsCount();
        if (count == 0)
            return null;
        int index = count - 1;
        var lines = UO.GetGumpButtonsDescription(index);
        foreach (object? line in (object? [])lines)
            UO.Print(Convert.ToString(line) ?? "");
        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.GetGumpButtonsDescription(gumpIndex) — UO.GetGumpButtonsDescription(Any)

Parametri: gumpIndex (Any)

Risultato: dynamic / Array.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "getgumpbuttonsdescription": return GumpLinesResult(bridge.GetGumpButtonsDescription(Arg(0)));

UO.GetGumpCount

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

Firme C#

int UO.GetGumpCount();

Versione breve GetGumpsCount: numero di gump del server attivi.

Parametri

Non ci sono parametri.

Valore restituito

int >= 0 — numero di finestre, non l'indice dell'ultima finestra. 0 — l'elenco è vuoto.

Comportamento

  • Funziona con gump server attivi. Zaino, mappa, impostazioni e altre finestre locali non sono incluse in questo elenco. Una chiamata legge i dati nel thread del gioco; chiamate diverse possono visualizzare stati diversi dell'elenco.

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 risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

var result = UO.GetGumpCount();
UO.Print("GetGumpCount: " + Convert.ToString(result));

1. Controlla le finestre del server: script diretto

Parametri e flusso di esecuzione:

  • Questo è il numero di gump del server, non l'indice della finestra; lo zaino locale e la mappa non sono inclusi qui.
int count = UO.GetGumpCount();
UO.Print($"Active server gumps: {count}");

2. Leggi ID finestra aperta - Funzione script

Parametri e flusso di esecuzione:

  • Gli indici partono da zero. L'elenco può cambiare tra una chiamata e l'altra, quindi la quantità corrente viene controllata prima della lettura.
return  RunScenario();
 object? RunScenario()
{
    int count = UO.GetGumpCount();
    for (int index = 0; index < count; index++)
    {
        if (index >= UO.GetGumpCount())
            break;
        UO.Print($"Gump {index}: ID={UO.GetGumpID(index)}, serial={UO.GetGumpSerial(index)}");
    }

    return null;
}

3. Attendi la finestra temporizzata - classe di script

Parametri e flusso di esecuzione:

  • L'attesa è limitata da un timeout. La semplice presenza di una finestra non dimostra che si tratti di uno spazio necessario; per selezionare, seleziona ID.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
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;
    }

    async public Task<object?> RunScenarioAsync()
    {
        bool appeared = await WaitForGump(3000);
        UO.Print(appeared ? "A server gump appeared" : "No server gump within the timeout");
        return null;
    }

    async Task<bool> WaitForGump(int timeoutMs)
    {
        var timer = System.Diagnostics.Stopwatch.StartNew();
        while (timer.ElapsedMilliseconds < timeoutMs)
        {
            if (UO.GetGumpCount() > 0)
                return true;
            await WaitAsync(50);
        }

        return false;
    }
}

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.GetGumpCount() — UO.GetGumpCount()

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int GetGumpCount() => bridge.GetGumpCount();

UO.GetGumpFullLines

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

Firme C#

dynamic UO.GetGumpFullLines(object? gumpIndex);

Restituisce le descrizioni di tutti gli elementi viventi, inclusi i gump dei server nidificati.

Parametri

  • gumpIndex — Obbligatorio int — indice del server attivo gump, da 0 a GetGumpsCount()-1. Questo non è GumpID/serial. Il numero negativo e l'indice fuori dall'elenco non sono validi. L'apertura, la chiusura e il riordino delle finestre possono modificare l'indice; controlla GetGumpID/GetGumpSerial prima di agire.

Valore restituito

Array - descrizioni di tutti gli elementi viventi, compresi quelli nidificati. [] - indice non valido o nessun elemento corrispondente. L'indice della riga inizia con 0; non è un controllo ID.

Comportamento

  • Funziona con gump server attivi. Zaino, mappa, impostazioni e altre finestre locali non sono incluse in questo elenco. Una chiamata legge i dati nel thread del gioco; chiamate diverse possono visualizzare stati diversi dell'elenco.
  • Descrizioni dell'albero di controllo corrente: tipo, pagina, ID, X/Y, dimensioni e campi supportati. Questo non è un pacchetto di markup del server raw.
  • Quando SilentMode=0 anche il risultato non vuoto viene aggiunto alla finestra di testo e la apre. SetSilentMode(1) lascia solo la restituzione dell'array.

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 risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

object? result = UO.GetGumpFullLines(0);
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

1. Leggi la prima riga: script diretto

Parametri e flusso di esecuzione:

  • 0 — indice della finestra. ArrayLength verifica la presenza di una linea prima di chiamare le linee[0].
var lines = UO.GetGumpFullLines(0);
if (Truth(ArrayLength(lines) > 0))
{
    UO.Print(lines[0]);
}

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;

2. Attraversa tutte le linee senza finestra automatica - funzione script

Parametri e flusso di esecuzione:

  • SetSilentMode(1) disabilita la finestra di testo aggiuntiva. La Print esplicita nell'esempio stampa ancora le stringhe.
  • i è l'indice dell'array; Prendere ID del pulsante/interruttore desiderato dalla descrizione corrispondente.
return  RunScenario();
 object? RunScenario()
{
    UO.SetSilentMode(1);
    var lines = UO.GetGumpFullLines(0);
    var i = 0;
    while (Truth(i < ArrayLength(lines)))
    {
        UO.Print(lines[i]);
        i = i + 1;
    }

    return null;
}

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;

3. Leggi i dati dell'ultima finestra del server aperta - Classe script

Parametri e flusso di esecuzione:

  • Il conteggio viene convertito nell'indice dell'ultima finestra. I dati vengono letti dal server gump caricato; le finestre locali non sono incluse qui.
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()
    {
        int count = UO.GetGumpsCount();
        if (count == 0)
            return null;
        int index = count - 1;
        var lines = UO.GetGumpFullLines(index);
        foreach (object? line in (object? [])lines)
            UO.Print(Convert.ToString(line) ?? "");
        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.GetGumpFullLines(gumpIndex) — UO.GetGumpFullLines(Any)

Parametri: gumpIndex (Any)

Risultato: dynamic / Array.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "getgumpfulllines": return GumpLinesResult(bridge.GetGumpFullLines(Arg(0)));

UO.GetGumpID

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

Firme C#

int UO.GetGumpID(object? gumpIndex);

Legge l'ID del tipo di finestra GumpID dall'indice Gump del server.

Parametri

  • gumpIndex — Obbligatorio int — indice del server attivo gump, da 0 a GetGumpsCount()-1. Questo non è GumpID/serial. Il numero negativo e l'indice fuori dall'elenco non sono validi. L'apertura, la chiusura e il riordino delle finestre possono modificare l'indice; controlla GetGumpID/GetGumpSerial prima di agire.

Valore restituito

int - Identificatore del tipo di finestra 32 bit GumpID. 0 è un indice non valido (serial=0 potrebbe essere presente anche nella finestra stessa). Quando è impostato il bit più significativo, int è negativo: utilizzare Hex(valore) per visualizzare. Questo non è il type di un argomento o un indice.

Comportamento

  • Funziona con gump server attivi. Zaino, mappa, impostazioni e altre finestre locali non sono incluse in questo elenco. Una chiamata legge i dati nel thread del gioco; chiamate diverse possono visualizzare stati diversi dell'elenco.
  • Per una coppia serial/GumpID abbinata, utilizza un GetGumpInfo: i campi info[0] e info[1].

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 risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

var result = UO.GetGumpID(0);
UO.Print("GetGumpID: " + Convert.ToString(result));

1. Mostra ID in esadecimale - script diretto

Parametri e flusso di esecuzione:

  • 0 è il primo indice dell'elenco dei server. Hex memorizza la rappresentazione in bit del negativo int.
var value = UO.GetGumpID(0);
UO.Print(Hex(value));

string Hex(object? value) => Convert.ToInt64(value).ToString("X");

2. Confini dell'elenco di controllo: funzione dello script

Parametri e flusso di esecuzione:

  • Con un elenco immutabile, il conteggio è dopo l'ultimo indice, quindi mancante=0. L'ultimo indice valido è count-1.
return  RunScenario();
 object? RunScenario()
{
    var count = UO.GetGumpsCount();
    var missing = UO.GetGumpID(count);
    UO.Print(Hex(missing));
    return null;
}

string Hex(object? value) => Convert.ToInt64(value).ToString("X");

3. Trova la finestra aperta tramite la nota ID - classe di script

Parametri e flusso di esecuzione:

  • 0x999 è un esempio di ID; sostituiscilo con il reale ID della finestra desiderata. Indice, ID e proprietario serial hanno valori diversi.
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()
    {
        int wantedId = 0x00000999;
        int count = UO.GetGumpsCount();
        for (int index = 0; index < count; index++)
        {
            if (index >= UO.GetGumpsCount())
                break;
            if (UO.GetGumpID(index) == wantedId)
            {
                UO.Print($"Gump index {index}, serial {UO.GetGumpSerial(index)}");
                return index;
            }
        }

        return -1;
        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.GetGumpID(gumpIndex) — UO.GetGumpID(Any)

Parametri: gumpIndex (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "getgumpid": return new InjectionValue(bridge.GetGumpId(Arg(0)));

UO.GetGumpInfo

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

Firme C#

dynamic UO.GetGumpInfo(object? gumpIndex);

Restituisce un'istantanea coerente degli identificatori e degli elementi di un singolo server gump.

Parametri

  • gumpIndex — Obbligatorio int — indice del server attivo gump, da 0 a GetGumpsCount()-1. Questo non è GumpID/serial. Il numero negativo e l'indice fuori dall'elenco non sono validi. L'apertura, la chiusura e il riordino delle finestre possono modificare l'indice; controlla GetGumpID/GetGumpSerial prima di agire.

Valore restituito

Array - esattamente cinque elementi: [0] int serial; [1] int GumpID; [2] Array di testi non vuoti; [3] Array descrizioni di pulsanti regolari; [4] Array di descrizioni di tutti gli elementi viventi, compresi quelli nidificati. Un gump non valido/chiuso o ignorato da questo script produce un array vuoto []. ID con il bit più significativo è rappresentato da un int negativo. Un array di testo vuoto di per sé non significa che non ci sia una finestra.

Comportamento

  • Funziona con gump server attivi. Zaino, mappa, impostazioni e altre finestre locali non sono incluse in questo elenco. Una chiamata legge i dati nel thread del gioco; chiamate diverse possono visualizzare stati diversi dell'elenco.
  • L'intera istantanea viene copiata in una richiesta del thread di gioco. La modifica/chiusura della finestra dopo il ritorno non modifica l'array salvato.
  • La descrizione del controllo indica il tipo, la pagina, ID, X/Y, dimensioni. I pulsanti contengono inoltre ButtonID, azione, toPage e graphic; interruttori - ID, selezionato, inattivo/attivo. I testi possono contenere spazi e =; La stringa non può essere analizzata incondizionatamente tramite spazi.
  • AddGumpIgnoreByID/AddGumpIgnoreBySerial nasconde il risultato di questa sola lettura nello script corrente; ClearGumpsIgnore rimuove questi filtri. GetGumpsCount non diminuisce.

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 risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

object? result = UO.GetGumpInfo(0);
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

1. Leggi entrambi ID - script diretto

Parametri e flusso di esecuzione:

  • GumpIndex=0 — il primo server gump. Il controllo della lunghezza protegge l'accesso ai campi della finestra mancanti.
  • info[0] — serial, info[1] — GumpID; entrambi appartengono alla stessa registrazione.
var info = UO.GetGumpInfo(0);
if (Truth(ArrayLength(info) == 5))
{
    UO.Print("Serial=" + Hex(info[0]));
    UO.Print("GumpID=" + Hex(info[1]));
}

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
string Hex(object? value) => Convert.ToInt64(value).ToString("X");
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;

2. Elenca i ButtonID reali - funzione dello script

Parametri e flusso di esecuzione:

  • info[3] — array di descrizioni dei pulsanti; il campo ButtonID nella riga specifica ID per la risposta. i è solo l'indice della riga, non il ButtonID.
  • I pulsanti di opzione sono pulsanti di opzione e vengono visualizzati in info[4], non nell'elenco dei pulsanti normali.
return  RunScenario();
 object? RunScenario()
{
    var info = UO.GetGumpInfo(0);
    if (Truth(ArrayLength(info) == 5))
    {
        var buttons = info[3];
        var i = 0;
        while (Truth(i < ArrayLength(buttons)))
        {
            UO.Print(buttons[i]);
            i = i + 1;
        }
    }

    return null;
}

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;

3. Salva il testo fino alla chiusura: classe di script

Parametri e flusso di esecuzione:

  • info[2] - copia dei testi. La chiusura è consentita solo per la finestra non inibita NoClose.
  • La chiusura non cancella i testi salvati; Per una finestra esistente è accettabile anche un array di testi vuoto.
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 info = UO.GetGumpInfo(0);
        if (Truth(ArrayLength(info) == 5))
        {
            var texts = info[2];
            UO.CloseSimpleGump(0);
            if (Truth(ArrayLength(texts) > 0))
            {
                UO.Print(texts[0]);
            }
        }

        return null;
    }

    int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
    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.GetGumpInfo(gumpIndex) — UO.GetGumpInfo(Any)

Parametri: gumpIndex (Any)

Risultato: dynamic / Array.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "getgumpinfo":

                {

                    int index = Arg(0);

                    GumpSnapshot snapshot;

                    if (bridge is IApiGumpAccess reader)

                        snapshot = reader.ReadGump(index);

                    else

                    {

                        int id = bridge.GetGumpId(index);

                        snapshot = id == 0 ? null : new GumpSnapshot(bridge.GetGumpSerial(index), id,

                            bridge.GetGumpTextLines(index), bridge.GetGumpButtonsDescription(index), bridge.GetGumpFullLines(index));

                    }

                    if (snapshot == null || state.IgnoredGumpIds.Contains(snapshot.Id)

                        || state.IgnoredGumpSerials.Contains(snapshot.Serial))

                        return new InjectionValue(Array.Empty<InjectionValue>());

                    return new InjectionValue(new[]

                    {

                        new InjectionValue(snapshot.Serial), new InjectionValue(snapshot.Id), StringArray(snapshot.Text),

                        StringArray(snapshot.Buttons), StringArray(snapshot.Controls)

                    });

                }

UO.GetGumpSerial

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

Firme C#

int UO.GetGumpSerial(object? gumpIndex);

Legge il proprietario dell'istanza/finestra serial in base all'indice Gump del server.

Parametri

  • gumpIndex — Obbligatorio int — indice del server attivo gump, da 0 a GetGumpsCount()-1. Questo non è GumpID/serial. Il numero negativo e l'indice fuori dall'elenco non sono validi. L'apertura, la chiusura e il riordino delle finestre possono modificare l'indice; controlla GetGumpID/GetGumpSerial prima di agire.

Valore restituito

int è il 32-bit serial dell'istanza/proprietario della finestra. 0 è un indice non valido (serial=0 potrebbe essere presente anche nella finestra stessa). Quando è impostato il bit più significativo, int è negativo: utilizzare Hex(valore) per visualizzare. Questo non è il type dell'argomento e non è un indice.

Comportamento

  • Funziona con gump server attivi. Zaino, mappa, impostazioni e altre finestre locali non sono incluse in questo elenco. Una chiamata legge i dati nel thread del gioco; chiamate diverse possono visualizzare stati diversi dell'elenco.
  • Per una coppia serial/GumpID abbinata, utilizza un GetGumpInfo: i campi info[0] e info[1].

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 risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

var result = UO.GetGumpSerial(0);
UO.Print("GetGumpSerial: " + Convert.ToString(result));

1. Mostra ID in esadecimale - script diretto

Parametri e flusso di esecuzione:

  • 0 è il primo indice dell'elenco dei server. Hex memorizza la rappresentazione in bit del negativo int.
var value = UO.GetGumpSerial(0);
UO.Print(Hex(value));

string Hex(object? value) => Convert.ToInt64(value).ToString("X");

2. Confini dell'elenco di controllo: funzione dello script

Parametri e flusso di esecuzione:

  • Con un elenco immutabile, il conteggio è dopo l'ultimo indice, quindi mancante=0. L'ultimo indice valido è count-1.
return  RunScenario();
 object? RunScenario()
{
    var count = UO.GetGumpsCount();
    var missing = UO.GetGumpSerial(count);
    UO.Print(Hex(missing));
    return null;
}

string Hex(object? value) => Convert.ToInt64(value).ToString("X");

3. Mostra i proprietari di tutte le finestre del server caricate - classe di script

Parametri e flusso di esecuzione:

  • Serial è di proprietà della finestra del server o del suo proprietario in base al contratto di comando. Non può essere utilizzato al posto dell'indice Gump.
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()
    {
        int count = UO.GetGumpsCount();
        for (int index = 0; index < count; index++)
        {
            if (index >= UO.GetGumpsCount())
                break;
            int serial = UO.GetGumpSerial(index);
            UO.Print($"Window {index}: serial={UO.Int2Hex(serial)}, ID={UO.GetGumpID(index)}");
        }

        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.GetGumpSerial(gumpIndex) — UO.GetGumpSerial(Any)

Parametri: gumpIndex (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "getgumpserial": return new InjectionValue(bridge.GetGumpSerial(Arg(0)));

UO.GetGumpShortLines

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

Firme C#

dynamic UO.GetGumpShortLines(object? gumpIndex);

Restituisce le descrizioni degli elementi di testo e dei pulsanti del server gump.

Parametri

  • gumpIndex — Obbligatorio int — indice del server attivo gump, da 0 a GetGumpsCount()-1. Questo non è GumpID/serial. Il numero negativo e l'indice fuori dall'elenco non sono validi. L'apertura, la chiusura e il riordino delle finestre possono modificare l'indice; controlla GetGumpID/GetGumpSerial prima di agire.

Valore restituito

Array - descrizioni di elementi di testo e pulsanti. [] - indice non valido o nessun elemento corrispondente. L'indice della riga inizia con 0; non è un controllo ID.

Comportamento

  • Funziona con gump server attivi. Zaino, mappa, impostazioni e altre finestre locali non sono incluse in questo elenco. Una chiamata legge i dati nel thread del gioco; chiamate diverse possono visualizzare stati diversi dell'elenco.
  • Dalla short list sono escluse le decorazioni senza testo e senza la tipologia Bottone; include pulsanti di opzione.
  • Quando SilentMode=0 anche il risultato non vuoto viene aggiunto alla finestra di testo e la apre. SetSilentMode(1) lascia solo la restituzione dell'array.

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 risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

object? result = UO.GetGumpShortLines(0);
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

1. Leggi la prima riga: script diretto

Parametri e flusso di esecuzione:

  • 0 — indice della finestra. ArrayLength verifica la presenza di una linea prima di chiamare le linee[0].
var lines = UO.GetGumpShortLines(0);
if (Truth(ArrayLength(lines) > 0))
{
    UO.Print(lines[0]);
}

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;

2. Attraversa tutte le linee senza finestra automatica - funzione script

Parametri e flusso di esecuzione:

  • SetSilentMode(1) disabilita la finestra di testo aggiuntiva. La Print esplicita nell'esempio stampa ancora le stringhe.
  • i è l'indice dell'array; Prendere ID del pulsante/interruttore desiderato dalla descrizione corrispondente.
return  RunScenario();
 object? RunScenario()
{
    UO.SetSilentMode(1);
    var lines = UO.GetGumpShortLines(0);
    var i = 0;
    while (Truth(i < ArrayLength(lines)))
    {
        UO.Print(lines[i]);
        i = i + 1;
    }

    return null;
}

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;

3. Leggi i dati dell'ultima finestra del server aperta - Classe script

Parametri e flusso di esecuzione:

  • Il conteggio viene convertito nell'indice dell'ultima finestra. I dati vengono letti dal server gump caricato; le finestre locali non sono incluse qui.
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()
    {
        int count = UO.GetGumpsCount();
        if (count == 0)
            return null;
        int index = count - 1;
        var lines = UO.GetGumpShortLines(index);
        foreach (object? line in (object? [])lines)
            UO.Print(Convert.ToString(line) ?? "");
        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.GetGumpShortLines(gumpIndex) — UO.GetGumpShortLines(Any)

Parametri: gumpIndex (Any)

Risultato: dynamic / Array.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "getgumpshortlines": return GumpLinesResult(bridge.GetGumpShortLines(Arg(0)));

UO.GetGumpTextLines

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

Firme C#

dynamic UO.GetGumpTextLines(object? gumpIndex);

Restituisce testi non vuoti di etichette, HTML, campi di input ed etichette di interruttori gump del server.

Parametri

  • gumpIndex — Obbligatorio int — indice del server attivo gump, da 0 a GetGumpsCount()-1. Questo non è GumpID/serial. Il numero negativo e l'indice fuori dall'elenco non sono validi. L'apertura, la chiusura e il riordino delle finestre possono modificare l'indice; controlla GetGumpID/GetGumpSerial prima di agire.

Valore restituito

Array — testi non vuoti di etichette, HTML, campi di input e etichette di commutazione. [] - indice non valido o nessun elemento corrispondente. L'indice della riga inizia con 0; non è il controllo ID.

Comportamento

  • Funziona con gump server attivi. Zaino, mappa, impostazioni e altre finestre locali non sono incluse in questo elenco. Una chiamata legge i dati nel thread del gioco; chiamate diverse possono visualizzare stati diversi dell'elenco.
  • Solo testo; ButtonID, dimensioni e struttura non sono inclusi. Non stampa nulla in più.
  • GetGumpTextLines non apre una finestra di testo.

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 risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

object? result = UO.GetGumpTextLines(0);
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

1. Leggi la prima riga: script diretto

Parametri e flusso di esecuzione:

  • 0 — indice della finestra. ArrayLength verifica la presenza di una linea prima di chiamare le linee[0].
var lines = UO.GetGumpTextLines(0);
if (Truth(ArrayLength(lines) > 0))
{
    UO.Print(lines[0]);
}

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;

2. Attraversa tutte le linee senza finestra automatica - funzione script

Parametri e flusso di esecuzione:

  • SetSilentMode(1) disabilita la finestra di testo aggiuntiva. La Print esplicita nell'esempio stampa ancora le stringhe.
  • i è l'indice dell'array; Prendere ID del pulsante/interruttore desiderato dalla descrizione corrispondente.
return  RunScenario();
 object? RunScenario()
{
    UO.SetSilentMode(1);
    var lines = UO.GetGumpTextLines(0);
    var i = 0;
    while (Truth(i < ArrayLength(lines)))
    {
        UO.Print(lines[i]);
        i = i + 1;
    }

    return null;
}

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;

3. Leggi i dati dell'ultima finestra del server aperta - Classe script

Parametri e flusso di esecuzione:

  • Il conteggio viene convertito nell'indice dell'ultima finestra. I dati vengono letti dal server gump caricato; le finestre locali non sono incluse qui.
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()
    {
        int count = UO.GetGumpsCount();
        if (count == 0)
            return null;
        int index = count - 1;
        var lines = UO.GetGumpTextLines(index);
        foreach (object? line in (object? [])lines)
            UO.Print(Convert.ToString(line) ?? "");
        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.GetGumpTextLines(gumpIndex) — UO.GetGumpTextLines(Any)

Parametri: gumpIndex (Any)

Risultato: dynamic / Array.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "getgumptextlines": return StringArray(bridge.GetGumpTextLines(Arg(0)));

UO.GetGumpsCount

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

Firme C#

int UO.GetGumpsCount();

Restituisce il numero di gump del server attivi.

Parametri

Non ci sono parametri.

Valore restituito

int >= 0 — numero di finestre, non l'indice dell'ultima finestra. 0 — l'elenco è vuoto.

Comportamento

  • Funziona con gump server attivi. Zaino, mappa, impostazioni e altre finestre locali non sono incluse in questo elenco. Una chiamata legge i dati nel thread del gioco; chiamate diverse possono visualizzare stati diversi dell'elenco.

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 risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

var result = UO.GetGumpsCount();
UO.Print("GetGumpsCount: " + Convert.ToString(result));

1. Verifica la presenza di Windows: script diretto

Parametri e flusso di esecuzione:

  • Non ci sono argomenti. count=0 significa che non ci sono finestre del server nell'elenco corrente.
var count = UO.GetGumpsCount();
if (Truth(count == 0))
{
    UO.Print("No server gumps");
}

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

2. Elenco ID - funzione dello script

Parametri e flusso di esecuzione:

  • i è l'indice con 0. Il ID risultante identifica i tipi di finestra anziché le posizioni nell'elenco.
  • Se le finestre cambiano durante la passeggiata è necessario rileggere l'elenco; count non blocca l'interfaccia.
return  RunScenario();
 object? RunScenario()
{
    var count = UO.GetGumpsCount();
    var i = 0;
    while (Truth(i < count))
    {
        UO.Print(Hex(UO.GetGumpID(i)));
        i = i + 1;
    }

    return null;
}

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

3. Leggi l'ultimo elemento dell'elenco: classe di script

Parametri e flusso di esecuzione:

  • count-1 è l'ultimo indice dell'elenco corrente, non una garanzia della finestra più recente. info è vuoto se la finestra è scomparsa prima della lettura.
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 count = UO.GetGumpsCount();
        if (Truth(count > 0))
        {
            var info = UO.GetGumpInfo(count - 1);
            UO.Print(ArrayLength(info));
        }

        return null;
    }

    int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
    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.GetGumpsCount() — UO.GetGumpsCount()

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "getgumpscount": return new InjectionValue(bridge.GetGumpCount());

UO.GumpAutoCheckBox

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

Firme C#

void UO.GumpAutoCheckBox(object? checkBoxID, object? value);

Imposta il valore dell'elemento una volta nel primo gump del server adatto; se l'elemento non esiste ancora, salva l'attesa.

Parametri

  • checkBoxID - int - esatto ID dell'elemento del tipo corrispondente. Questo non è un indice, non un GumpID e non una finestra serial; 0 è il solito ID, senza sostituzione del primo elemento.
  • value - int - 1 abilita, 0 disabilita. I valori numerici diversi da zero includono anche; Si consigliano 0/1. La selezione di un pulsante di opzione deseleziona i pulsanti di opzione vicini del suo gruppo.

Valore restituito

void - non restituisce nulla: né successo, né un nuovo valore, né conferma del server.

Comportamento

  • Innanzitutto controlla le finestre esistenti nell'ordine corrente dell'interfaccia, quindi i layout del server nuovi o aggiornati. Si attiva una volta alla prima corrispondenza di tipo e ID. Per una finestra specifica, utilizzare NumGump* con un indice.
  • Tutti i campi in sospeso vengono applicati prima delle risposte automatiche ai pulsanti. La ripetizione dello stesso tipo e ID in uno script sostituisce un valore che non è stato ancora eseguito. Limite: 1024 campi cliente in sospeso; il superamento provoca un errore di script.
  • Il normale completamento della procedura risparmia l'attesa. Cancellando il titolare o Terminate con il suo nome si tolgono le sue attese; TerminateAll cancella tutto, compresi quelli rimasti dopo il completamento delle procedure. Cambiare il mondo cancella la coda. Le aspettative non vengono salvate nel profilo.

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.GumpAutoCheckBox");
UO.GumpAutoCheckBox(33, 1);

1. Riempimento immediato - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Il primo parametro 33 è un esempio ID dell'elemento desiderato; sostituiscilo con il vero ID di InfoGump. Il secondo è il valore da impostare. Se non è presente alcun elemento, l'azione rimane in sospeso.
UO.GumpAutoCheckBox(33, 1);

2. Riempi prima dell'apertura: funzione script

Parametri e flusso di esecuzione:

  • 33 è ID dell'elemento, 100 è un esempio di ButtonID di conferma, 0x40001234 è serial dell'oggetto che apre il form. Sostituisci tutti e tre i valori con i tuoi. Il campo verrà compilato prima della risposta, anche se la finestra è arrivata più tardi.
return  RunScenario();
 object? RunScenario()
{
    UO.GumpAutoCheckBox(33, 1);
    UO.WaitGump(100);
    UO.UseObject("0x40001234");
    return null;
}

3. Sostituzione di un valore in sospeso - Classe di script

Parametri e flusso di esecuzione:

  • Entrambe le chiamate utilizzano ID 33. Se l'elemento non è ancora apparso, vale l'ultimo valore. Se la finestra è già aperta, entrambe le modifiche vengono eseguite immediatamente in ordine.
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.GumpAutoCheckBox(33, 1);
        UO.GumpAutoCheckBox(33, 0);
        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.GumpAutoCheckBox(checkBoxID, value) — UO.GumpAutoCheckBox(Any,Any)

Parametri: checkBoxID (Any), value (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "gumpautocheckbox": QueueGumpControl("checkbox", Arg(0), Text(1)); return InjectionValue.Unit;

UO.GumpAutoRadiobutton

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

Firme C#

void UO.GumpAutoRadiobutton(object? radiobuttonID, object? value);

Imposta il valore dell'elemento una volta nel primo gump del server adatto; se l'elemento non esiste ancora, salva l'attesa.

Parametri

  • radiobuttonID - int - esatto ID dell'elemento del tipo corrispondente. Questo non è un indice, non un GumpID e non una finestra serial; 0 è il solito ID, senza sostituzione del primo elemento.
  • value - int - 1 abilita, 0 disabilita. I valori numerici diversi da zero includono anche; Si consigliano 0/1. La selezione di un pulsante di opzione deseleziona i pulsanti di opzione vicini del suo gruppo.

Valore restituito

void - non restituisce nulla: né successo, né un nuovo valore, né conferma del server.

Comportamento

  • Innanzitutto controlla le finestre esistenti nell'ordine corrente dell'interfaccia, quindi i layout del server nuovi o aggiornati. Si attiva una volta alla prima corrispondenza di tipo e ID. Per una finestra specifica, utilizzare NumGump* con un indice.
  • Tutti i campi in sospeso vengono applicati prima delle risposte automatiche ai pulsanti. La ripetizione dello stesso tipo e ID in uno script sostituisce un valore che non è stato ancora eseguito. Limite: 1024 campi cliente in sospeso; il superamento provoca un errore di script.
  • Il normale completamento della procedura risparmia l'attesa. Cancellando il titolare o Terminate con il suo nome si tolgono le sue attese; TerminateAll cancella tutto, compresi quelli rimasti dopo il completamento delle procedure. Cambiare il mondo cancella la coda. Le aspettative non vengono salvate nel profilo.

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.GumpAutoRadiobutton");
UO.GumpAutoRadiobutton(33, 1);

1. Riempimento immediato - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Il primo parametro 33 è un esempio ID dell'elemento desiderato; sostituiscilo con il vero ID di InfoGump. Il secondo è il valore da impostare. Se non è presente alcun elemento, l'azione rimane in sospeso.
UO.GumpAutoRadiobutton(33, 1);

2. Riempi prima dell'apertura: funzione script

Parametri e flusso di esecuzione:

  • 33 è ID dell'elemento, 100 è un esempio di ButtonID di conferma, 0x40001234 è serial dell'oggetto che apre il form. Sostituisci tutti e tre i valori con i tuoi. Il campo verrà compilato prima della risposta, anche se la finestra è arrivata più tardi.
return  RunScenario();
 object? RunScenario()
{
    UO.GumpAutoRadiobutton(33, 1);
    UO.WaitGump(100);
    UO.UseObject("0x40001234");
    return null;
}

3. Sostituzione di un valore in sospeso - Classe di script

Parametri e flusso di esecuzione:

  • Entrambe le chiamate utilizzano ID 33. Se l'elemento non è ancora apparso, vale l'ultimo valore. Se la finestra è già aperta, entrambe le modifiche vengono eseguite immediatamente in ordine.
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.GumpAutoRadiobutton(33, 1);
        UO.GumpAutoRadiobutton(33, 0);
        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.GumpAutoRadiobutton(radiobuttonID, value) — UO.GumpAutoRadiobutton(Any,Any)

Parametri: radiobuttonID (Any), value (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "gumpautoradiobutton": QueueGumpControl("radio", Arg(0), Text(1)); return InjectionValue.Unit;

UO.GumpAutoTextEntry

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

Firme C#

void UO.GumpAutoTextEntry(object? textEntryID, object? value);

Imposta il valore dell'elemento una volta nel primo gump del server adatto; se l'elemento non esiste ancora, salva l'attesa.

Parametri

  • textEntryID - int - esatto ID dell'elemento del tipo corrispondente. Questo non è un indice, non un GumpID e non una finestra serial; 0 è il solito ID, senza sostituzione del primo elemento.
  • value - string - testo del campo, inclusa una riga vuota da cancellare. Le restrizioni sulla lunghezza e sui caratteri consentiti del campo stesso vengono mantenute.

Valore restituito

void - non restituisce nulla: né successo, né un nuovo valore, né conferma del server.

Comportamento

  • Innanzitutto controlla le finestre esistenti nell'ordine corrente dell'interfaccia, quindi i layout del server nuovi o aggiornati. Si attiva una volta alla prima corrispondenza di tipo e ID. Per una finestra specifica, utilizzare NumGump* con un indice.
  • Tutti i campi in sospeso vengono applicati prima delle risposte automatiche ai pulsanti. La ripetizione dello stesso tipo e ID in uno script sostituisce un valore che non è stato ancora eseguito. Limite: 1024 campi cliente in sospeso; il superamento provoca un errore di script.
  • Il normale completamento della procedura risparmia l'attesa. Cancellando il titolare o Terminate con il suo nome si tolgono le sue attese; TerminateAll cancella tutto, compresi quelli rimasti dopo il completamento delle procedure. Cambiare il mondo cancella la coda. Le aspettative non vengono salvate nel profilo.
  • Il testo delimitato da un campo può essere abbreviato o rifiutato; l'elemento trovato consuma comunque un'azione una tantum. Il comando non invia una risposta tramite pulsante e non attende il server. Per verificare, utilizzare GetGumpInfo/NumGumpTextEntry.

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.GumpAutoTextEntry");
UO.GumpAutoTextEntry(33, "500");

1. Riempimento immediato - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Il primo parametro 33 è un esempio ID dell'elemento desiderato; sostituiscilo con il vero ID di InfoGump. Il secondo è il valore da impostare. Se non è presente alcun elemento, l'azione rimane in sospeso.
UO.GumpAutoTextEntry(33, "500");

2. Riempi prima dell'apertura: funzione script

Parametri e flusso di esecuzione:

  • 33 è ID dell'elemento, 100 è un esempio di ButtonID di conferma, 0x40001234 è serial dell'oggetto che apre il form. Sostituisci tutti e tre i valori con i tuoi. Il campo verrà compilato prima della risposta, anche se la finestra è arrivata più tardi.
return  RunScenario();
 object? RunScenario()
{
    UO.GumpAutoTextEntry(33, "500");
    UO.WaitGump(100);
    UO.UseObject("0x40001234");
    return null;
}

3. Sostituzione di un valore in sospeso - Classe di script

Parametri e flusso di esecuzione:

  • Entrambe le chiamate utilizzano ID 33. Se l'elemento non è ancora apparso, vale l'ultimo valore. Se la finestra è già aperta, entrambe le modifiche vengono eseguite immediatamente in ordine.
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.GumpAutoTextEntry(33, "500");
        UO.GumpAutoTextEntry(33, "");
        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.GumpAutoTextEntry(textEntryID, value) — UO.GumpAutoTextEntry(Any,Any)

Parametri: textEntryID (Any), value (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "gumpautotextentry": QueueGumpControl("textentry", Arg(0), Text(1)); return InjectionValue.Unit;

UO.GumpExists

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

Firme C#

int UO.GumpExists(object? id);
int UO.GumpExists(object? firstId, object? secondId);

Verifica la presenza di un server Gump utilizzando un selettore o la coppia esatta serial/GumpID.

Parametri

  • id — Forma con un argomento: numerico serial, GumpID o indice con 0. -1 non seleziona l'ultimo gump qui.
  • firstId — Forma a due argomenti: numerico 32-bit serial, incluso il negativo int con il bit più significativo.
  • secondId — Forma a due argomenti: GumpID esatto a 32 bit. 0 è un numero esatto, non un carattere jolly. Solo -1 torna al controllo con un argomento di firstId come serial/GumpID/index.

Valore restituito

int - 1, se la finestra corrispondente esiste adesso; 0 altrimenti. Non restituisce l'indice, serial o il numero di corrispondenze.

Comportamento

  • Funziona con gump server attivi. Zaino, mappa, impostazioni e altre finestre locali non sono incluse in questo elenco. Una chiamata legge i dati nel thread del gioco; chiamate diverse possono visualizzare stati diversi dell'elenco.
  • Il controllo non seleziona una finestra e non la riserva. La coppia ID viene controllata nel suo insieme; ID con il bit più significativo non disabilita il filtro.

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 risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

var result = UO.GumpExists(0x87654321);
UO.Print("GumpExists: " + Convert.ToString(result));

1. Controlla noto ID - script diretto

Parametri e flusso di esecuzione:

  • 0x87654321: il GumpID desiderato o serial. Un argomento non distingue tra questi spazi ID.
var exists = UO.GumpExists(0x87654321);
UO.Print(Convert.ToString(exists));

2. Controlla la coppia esatta - funzione script

Parametri e flusso di esecuzione:

  • Il primo numero è serial, il secondo è GumpID. Entrambi sono negativi nel segno int, ma il confronto preserva tutti i bit 32.
return  RunScenario();
 object? RunScenario()
{
    var exists = UO.GumpExists(0x87654321, 0x98765432);
    if (Truth(exists))
    {
        UO.Print("Matching pair exists");
    }

    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. Controlla gli identificatori salvati - Classe script

Parametri e flusso di esecuzione:

  • info[0]/info[1] appartengono alla stessa immagine. esiste=1 significa che la coppia esiste adesso; una finestra riaperta con la stessa coppia non è diversa dalla precedente.
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 info = UO.GetGumpInfo(0);
        if (Truth(ArrayLength(info) == 5))
        {
            var exists = UO.GumpExists(info[0], info[1]);
            UO.Print(Convert.ToString(exists));
        }

        return null;
    }

    int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
    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.GumpExists(id) — UO.GumpExists(Any)

Parametri: id (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int GumpExists(InjectionValue id) => bridge.GumpExists(NumberConversions.ToInt(id), -1);

UO.GumpExists(firstId, secondId) — UO.GumpExists(Any,Any)

Parametri: firstId (Any), secondId (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int GumpExists(InjectionValue firstId, InjectionValue secondId)

            => bridge.GumpExists(NumberConversions.ToInt(firstId), NumberConversions.ToInt(secondId));

UO.GumpObject

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

Firme C#

void UO.GumpObject(object? gumpId);

Seleziona un server gump esistente per le chiamate successive.

Parametri

  • gumpId - int: corrisponde prima a LocalSerial o ServerSerial, quindi indicizza zero nell'elenco gumps corrente. Questi non sono pulsanti ID.

Valore restituito

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

Comportamento

  • Bridge.SelectGump salva _selectedServerGump. Se serial non corrisponde, prende l'indice 0..count-1. Non trovato: il gump selezionato diventa null e viene visualizzato un messaggio.
  • Gump non si apre e non viene inviata alcuna risposta al server. Gli indici cambiano quando le finestre vengono aperte/chiuse; per una selezione stabile utilizzare l'attuale serial/id.

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.GumpObject");
UO.GumpObject(0);

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Seleziona un server gump esistente per le chiamate successive.
if (Truth(UO.GumpExists(0)))
{
    UO.GumpObject(0);
}

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

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • Bridge.SelectGump salva _selectedServerGump. Se serial non corrisponde, prende l'indice 0..count-1. Non trovato: il gump selezionato diventa null e viene visualizzato un messaggio.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.GetGumpsCount() > 0))
    {
        var serial = UO.GetGumpSerial(0);
        UO.GumpObject(serial);
    }

    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. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

  • Gump non si apre e non viene inviata alcuna risposta al server. Gli indici cambiano quando le finestre vengono aperte/chiuse; per una selezione stabile utilizzare l'attuale serial/id.
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()
    {
        if (Truth(UO.GetGumpsCount() > 0))
        {
            UO.GumpObject(0);
            UO.Print(UO.LastGump("gumpid"));
        }

        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.GumpObject(gumpId) — UO.GumpObject(Any)

Parametri: gumpId (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "gumpobject": bridge.SelectGump(Arg(0)); break;

UO.IsGump

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

Firme C#

int UO.IsGump();

Controlla se c'è almeno un server gump attivo.

Parametri

Non ci sono parametri.

Valore restituito

int — 1, se la lista non è vuota; 0 se vuoto. Questo è un segno di disponibilità, non il numero di finestre.

Comportamento

  • Funziona con gump server attivi. Zaino, mappa, impostazioni e altre finestre locali non sono incluse in questo elenco. Una chiamata legge i dati nel thread del gioco; chiamate diverse possono visualizzare stati diversi dell'elenco.

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 risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

var result = UO.IsGump();
UO.Print("IsGump: " + Convert.ToString(result));

1. Lettura condizionale - Script diretto

Parametri e flusso di esecuzione:

  • Non ci sono argomenti. GetGumpInfo(0) legge il primo elemento e può restituire un array vuoto se la finestra è già stata chiusa.
if (Truth(UO.IsGump()))
{
    var info = UO.GetGumpInfo(0);
    UO.Print(ArrayLength(info));
}

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;

2. Distinguere tra quantità e presenza - funzione dello script

Parametri e flusso di esecuzione:

  • Con tre finestre stabili presenti=1, conteggio=3.
return  RunScenario();
 object? RunScenario()
{
    var present = UO.IsGump();
    var count = UO.GetGumpsCount();
    UO.Print(Convert.ToString(present) + "/" + Convert.ToString(count));
    return null;
}

3. Attesa limitata - Classe di script

Parametri e flusso di esecuzione:

  • Attendere al massimo circa 3000 ms, controllare ogni 50 ms. Il regalo finale mostra lo stato dopo l'attesa.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
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;
    }

    async public Task<object?> RunScenarioAsync()
    {
        var started = Now();
        while (Truth(UO.IsGump() == 0) && Truth(Now() - started < 3000))
        {
            await Delay(50);
        }

        var present = UO.IsGump();
        return null;
    }

    Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
    bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
    private int Now() => global::ClassicUO.CSharp.CSharpScriptContext.Current.Now();
}

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.IsGump() — UO.IsGump()

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "isgump": return new InjectionValue(bridge.GetGumpCount() > 0 ? 1 : 0);

UO.IsGumpCanBeClosed

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

Firme C#

int UO.IsGumpCanBeClosed(object? gumpIndex);

Controlla se è consentita la chiusura locale del gump del server con il tasto destro del mouse.

Parametri

  • gumpIndex — Obbligatorio int — indice del server attivo gump, da 0 a GetGumpsCount()-1. Questo non è GumpID/serial. Il numero negativo e l'indice fuori dall'elenco non sono validi. L'apertura, la chiusura e il riordino delle finestre possono modificare l'indice; controlla GetGumpID/GetGumpSerial prima di agire.

Valore restituito

int — 1, se la finestra esiste e CanCloseWithRightClick è abilitato; altrimenti 0. Questo non è il risultato della chiusura o della presenza di un pulsante Annulla.

Comportamento

  • Funziona con gump server attivi. Zaino, mappa, impostazioni e altre finestre locali non sono incluse in questo elenco. Una chiamata legge i dati nel thread del gioco; chiamate diverse possono visualizzare stati diversi dell'elenco.
  • NoClose vieta CloseSimpleGump; la possibilità di inviare ButtonID al server è un'azione separata.

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 risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

var result = UO.IsGumpCanBeClosed(0);
UO.Print("IsGumpCanBeClosed: " + Convert.ToString(result));

1. Chiusura condizionale - script diretto

Parametri e flusso di esecuzione:

  • 0 — indice della finestra. La verifica e la chiusura sono sfide diverse; l'indice può cambiare tra di loro.
if (Truth(UO.IsGumpCanBeClosed(0)))
{
    UO.CloseSimpleGump(0);
}

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

2. Mostra Chiudi Disabilita - Funzione script

Parametri e flusso di esecuzione:

  • closable=0 su una finestra esistente significa che la finestra non può essere chiusa, non l'assenza della finestra.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.GetGumpsCount() > 0))
    {
        var closable = UO.IsGumpCanBeClosed(0);
        UO.Print(Convert.ToString(closable));
    }

    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. Indice non valido - classe script

Parametri e flusso di esecuzione:

  • -1 non è valido per questo comando indice e restituisce 0; questa non è l'ultima selezione della finestra.
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 result = UO.IsGumpCanBeClosed(-1);
        UO.Print(Convert.ToString(result));
        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.IsGumpCanBeClosed(gumpIndex) — UO.IsGumpCanBeClosed(Any)

Parametri: gumpIndex (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "isgumpcanbeclosed": return new InjectionValue(bridge.IsGumpCanBeClosed(Arg(0)));

UO.LastGump

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

Firme C#

dynamic UO.LastGump(object? identifier);
dynamic UO.LastGump(object? identifier, object? key);

Legge un campo del gump del server selezionato. Utilizza la finestra selezionata da questo script o l'ultimo elemento dell'elenco corrente.

Parametri

  • identifier - string senza distinzione tra maiuscole e minuscole. Tutti i valori e i tipi di risultati supportati sono elencati nella sezione Resi. Il nome sconosciuto restituisce una stringa vuota.
  • key - Opzionale int, predefinito - 1. Indice con 0 per pulsante/testo/object/comando; questo non è il controllo ID. Un indice negativo e fuori dai limiti risulta in 0 per il pulsante o una stringa vuota per i campi di testo. Altri identificatori non utilizzano la chiave.

Valore restituito

Il tipo del risultato dipende dall'identificatore. int: buttonlen — numero di pulsanti regolari; button — ButtonID per chiave indice; textlen: numero di elementi di testo disponibili; injid: indice della finestra corrente; risposto — 0 (la cronologia delle risposte non viene memorizzata); inclient — 1 per una finestra live trovata, 0 se assente; objectcount: numero di controlli live, inclusi quelli nidificati. string: serial e gumpid - stringhe esadecimali 0xXXXXXXXX; text — testo dell'elemento nella chiave dell'indice; object — nome del tipo di controllo; comando — descrizione del controllo (tipo, pagina, ID, coordinate, dimensioni e campi supportati). Se non è presente alcuna finestra, gli identificatori numerici danno 0, gli identificatori di stringa danno una stringa vuota. injid=0 è anche un primo indice valido: 0 di per sé non dimostra l'assenza di una finestra. Questo non è Array o Pascal TGumpInfo.

Comportamento

  • Funziona con gump server attivi. Zaino, mappa, impostazioni e altre finestre locali non sono incluse in questo elenco. Una chiamata legge i dati nel thread del gioco; chiamate diverse possono visualizzare stati diversi dell'elenco.
  • SelectGump/InfoGump specifica la finestra selezionata solo nel runtime corrente. Se la finestra selezionata viene chiusa, viene utilizzato l'ultimo elemento dell'elenco corrente, che non è necessariamente l'elemento più recente nel tempo.
  • textlen/text fa riferimento ai controlli di testo disponibili, non al pool di stringhe originale del pacchetto server. object/command si riferisce all'intero albero dei controlli live. Non è possibile mischiare indici di elenchi diversi.
  • Ogni chiamata legge lo stato corrente separatamente. Per serial, GumpID ed elenchi corrispondenti, utilizzare GetGumpInfo.

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 risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

object? result = UO.LastGump("gumpid");
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

1. Leggi ID della finestra selezionata - script diretto

Parametri e flusso di esecuzione:

  • gumpid e serial restituiscono stringhe già formattate in esadecimale; non è necessario alcun esagono aggiuntivo. Le righe vuote indicano che non è presente alcuna finestra durante la lettura.
var id = UO.LastGump("gumpid");
var serial = UO.LastGump("serial");
UO.Print(id + " / " + serial);

2. Enumerare ButtonID - Funzione script

Parametri e flusso di esecuzione:

  • buttonlen: numero di pulsanti; i è l'indice della riga da 0 a count-1. pulsante - ID per la risposta, non grafica o indice. Quando cambi finestra, rileggi l'elenco.
return  RunScenario();
 object? RunScenario()
{
    var count = UO.LastGump("buttonlen");
    var i = 0;
    while (Truth(i < count))
    {
        var button = UO.LastGump("button", i);
        UO.Print(Convert.ToString(button));
        i = i + 1;
    }

    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. Leggi il testo dopo la selezione - classe di script

Parametri e flusso di esecuzione:

  • 0x12345678 è un esempio di GumpID/serial, sostituisci ID con la forma desiderata. text with key=0 legge il primo controllo di testo disponibile; questo è un elenco diverso dal pulsante.
  • SelectGump segnala l'assenza della finestra specificata, ma non blocca la successiva lettura: verificare separatamente il gumpid restituito se necessario.
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.SelectGump(0x12345678);
        if (Truth(UO.LastGump("inclient")))
        {
            var count = UO.LastGump("textlen");
            if (Truth(count > 0))
            {
                UO.Print(UO.LastGump("text", 0));
            }
        }

        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.LastGump(identifier) — UO.LastGump(String)

Parametri: identifier (String)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public InjectionValue LastGump(string identifier) => LastGump(identifier, -1);

UO.LastGump(identifier, key) — UO.LastGump(String,Integer)

Parametri: identifier (String), key (Integer)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public InjectionValue LastGump(string identifier, int key) => ConvertGumpValue(identifier, bridge.GetGumpValue(-1, identifier, key));

UO.NumGumpButton

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

Firme C#

int UO.NumGumpButton(object? gumpIndex, object? value);

Attiva un pulsante gump del server esistente in base all'indice rigoroso della finestra e all'esatto ButtonID.

Parametri

  • gumpIndex — Obbligatorio int — indice del server attivo gump, da 0 a GetGumpsCount()-1. Questo non è GumpID/serial. Il numero negativo e l'indice fuori dall'elenco non sono validi. L'apertura, la chiusura e il riordino delle finestre possono modificare l'indice; controlla GetGumpID/GetGumpSerial prima di agire.
  • value - int - ButtonID dalla descrizione di un pulsante normale. Non il numero di riga, non il pulsante graphic, non il GumpID.

Valore restituito

int (bool) - 1, se la finestra e il pulsante vengono trovati e viene eseguita l'azione locale; 0 se non è presente alcuna finestra/pulsante. Anche la modifica della pagina restituisce 1. Questa non è una conferma dell'elaborazione del server.

Il risultato del comando è un flag numerico: 1 significa una condizione soddisfatta, 0 significa una condizione non soddisfatta. Dopo var risultato = comando(...) controlla se (risultato != 0) o se (risultato == 0). Salva il risultato di una chiamata: una chiamata ripetuta può eseguire nuovamente l'azione o leggere lo stato che è già cambiato.

Comportamento

  • Funziona con gump server attivi. Zaino, mappa, impostazioni e altre finestre locali non sono incluse in questo elenco. Una chiamata legge i dati nel thread del gioco; chiamate diverse possono visualizzare stati diversi dell'elenco.
  • Il pulsante SwitchPage cambia la pagina localmente. Il pulsante Attiva provoca una risposta goffa; la finestra di solito si chiude. A differenza di SendGumpSelect, questo comando richiede un ButtonID esistente nell'albero di controllo.

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 risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

var result = UO.NumGumpButton(0, 77);
UO.Print("NumGumpButton: " + Convert.ToString(result));

1. Premi un pulsante noto: script diretto

Parametri e flusso di esecuzione:

  • 0 è l'indice della finestra, 77 è un esempio ButtonID dell'ispettore. Il tuo modulo ha bisogno del suo vero ID.
var ok = UO.NumGumpButton(0, 77);
if (Truth(ok == 0))
{
    UO.Print("Button not found");
}

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

2. Controlla prima il tipo di finestra: funzione script

Parametri e flusso di esecuzione:

  • 0x12345678 è il GumpID previsto, 100 è il ButtonID. Questi due numeri appartengono a spazi diversi ID.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.GetGumpID(0) == 0x12345678))
    {
        var ok = UO.NumGumpButton(0, 100);
    }

    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. Cambia la casella di controllo prima del pulsante - Classe di script

Parametri e flusso di esecuzione:

  • 33 - casella di controllo ID, 1 - abilita, 100 - pulsante ID. Lo stato della casella di controllo verrà incluso nella risposta solo per il pulsante Attiva.
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()
    {
        if (Truth(UO.NumGumpCheckBox(0, 33, 1)))
        {
            var ok = UO.NumGumpButton(0, 100);
        }

        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.NumGumpButton(gumpIndex, value) — UO.NumGumpButton(Any,Any)

Parametri: gumpIndex (Any), value (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "numgumpbutton": return (bridge is IApiGumpAccess buttons

                    ? buttons.ActivateGumpButtonAtIndex(Arg(0), Arg(1)) : bridge.ActivateGumpButton(Arg(0), Arg(1))) != 0 ? InjectionValue.True : InjectionValue.False;

UO.NumGumpCheckBox

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

Firme C#

int UO.NumGumpCheckBox(object? gumpIndex, object? cbid, object? value);

Imposta lo stato del flag nel server gump per indice.

Parametri

  • gumpIndex — Obbligatorio int — indice del server attivo gump, da 0 a GetGumpsCount()-1. Questo non è GumpID/serial. Il numero negativo e l'indice fuori dall'elenco non sono validi. L'apertura, la chiusura e il riordino delle finestre possono modificare l'indice; controlla GetGumpID/GetGumpSerial prima di agire.
  • cbid - int - l'esatto elemento ID dalla descrizione del gump. Questo non è il numero di serie dell'elemento; la ID mancante non viene sostituita con un indice.
  • value — int — 1 abilita/seleziona, 0 disabilita. Vengono riconosciuti anche i valori numerici diversi da zero, true e check. Si consigliano 0 e 1.

Valore restituito

int (bool) — 1, se l'elemento richiesto viene trovato e il suo valore finale corrisponde a quello specificato; 0 se l'indice non è valido, manca il tipo ID/elemento, oppure se il campo non ha assunto un valore esatto. Anche la reimpostazione di un valore già impostato ha esito positivo.

Il risultato del comando è un flag numerico: 1 significa una condizione soddisfatta, 0 significa una condizione non soddisfatta. Dopo var risultato = comando(...) controlla se (risultato != 0) o se (risultato == 0). Salva il risultato di una chiamata: una chiamata ripetuta può eseguire nuovamente l'azione o leggere lo stato che è già cambiato.

Comportamento

  • Funziona con gump server attivi. Zaino, mappa, impostazioni e altre finestre locali non sono incluse in questo elenco. Una chiamata legge i dati nel thread del gioco; chiamate diverse possono visualizzare stati diversi dell'elenco.
  • Cambia lo stato locale. I campi e i pulsanti di opzione selezionati vengono inviati seguiti dalla risposta del pulsante.
  • La selezione di un pulsante di opzione deseleziona il pulsante di opzione adiacente dello stesso gruppo; le caselle di controllo regolari sono indipendenti.

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 risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

var result = UO.NumGumpCheckBox(0, 33, 1);
UO.Print("NumGumpCheckBox: " + Convert.ToString(result));

1. Imposta il valore e controlla il risultato: script diretto

Parametri e flusso di esecuzione:

  • 0 — indice della finestra; 33 — esatto CBID; 1 - nuovo valore. Sostituisci 33 con ID del tuo gump.
var ok = UO.NumGumpCheckBox(0, 33, 1);
if (Truth(ok == 0))
{
    UO.Print("Control missing or value rejected");
}

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

2. Cancella valore - Funzione script

Parametri e flusso di esecuzione:

  • 0 cancella il campo o lo deseleziona. Viene restituito l'esito positivo della modifica, non il nuovo valore del campo.
return  RunScenario();
 object? RunScenario()
{
    var ok = UO.NumGumpCheckBox(0, 33, 0);
    UO.Print(Convert.ToString(ok));
    return null;
}

3. Compila prima di rispondere - Classe di script

Parametri e flusso di esecuzione:

  • 100 - esempio di conferma ButtonID del server; deve essere sostituito ID della tua finestra. Da 0 a SendGumpSelect(0,100) è l'indice della finestra.
  • La risposta può chiudere il gump e cambiare gli indici. inviato significa invio locale, risultato di un'operazione non confermata dal server.
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()
    {
        if (Truth(UO.NumGumpCheckBox(0, 33, 1)))
        {
            var sent = UO.SendGumpSelect(0, 100);
            UO.Print(Convert.ToString(sent));
        }

        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.NumGumpCheckBox(gumpIndex, cbid, value) — UO.NumGumpCheckBox(Any,Any,Any)

Parametri: gumpIndex (Any), cbid (Any), value (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "numgumpcheckbox": return SetIndexedGumpValue(Arg(0), "checkbox", Arg(1), Text(2));

UO.NumGumpRadiobutton

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

Firme C#

int UO.NumGumpRadiobutton(object? gumpIndex, object? radiobuttonID, object? value);

Imposta lo stato di un pulsante di opzione in un server gump per indice.

Parametri

  • gumpIndex — Obbligatorio int — indice del server attivo gump, da 0 a GetGumpsCount()-1. Questo non è GumpID/serial. Il numero negativo e l'indice fuori dall'elenco non sono validi. L'apertura, la chiusura e il riordino delle finestre possono modificare l'indice; controlla GetGumpID/GetGumpSerial prima di agire.
  • radiobuttonID - int - l'esatto elemento ID dalla descrizione del gump. Questo non è il numero di serie dell'elemento; la ID mancante non viene sostituita con un indice.
  • value — int — 1 abilita/seleziona, 0 disabilita. Vengono riconosciuti anche i valori numerici diversi da zero, true e check. Si consigliano 0 e 1.

Valore restituito

int (bool) — 1, se l'elemento richiesto viene trovato e il suo valore finale corrisponde a quello specificato; 0 se l'indice non è valido, manca il tipo ID/elemento, oppure se il campo non ha assunto un valore esatto. Anche la reimpostazione di un valore già impostato ha esito positivo.

Il risultato del comando è un flag numerico: 1 significa una condizione soddisfatta, 0 significa una condizione non soddisfatta. Dopo var risultato = comando(...) controlla se (risultato != 0) o se (risultato == 0). Salva il risultato di una chiamata: una chiamata ripetuta può eseguire nuovamente l'azione o leggere lo stato che è già cambiato.

Comportamento

  • Funziona con gump server attivi. Zaino, mappa, impostazioni e altre finestre locali non sono incluse in questo elenco. Una chiamata legge i dati nel thread del gioco; chiamate diverse possono visualizzare stati diversi dell'elenco.
  • Cambia lo stato locale. I campi e i pulsanti di opzione selezionati vengono inviati seguiti dalla risposta del pulsante.
  • La selezione di un pulsante di opzione deseleziona il pulsante di opzione adiacente dello stesso gruppo; le caselle di controllo regolari sono indipendenti.

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 risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

var result = UO.NumGumpRadiobutton(0, 33, 1);
UO.Print("NumGumpRadiobutton: " + Convert.ToString(result));

1. Imposta il valore e controlla il risultato: script diretto

Parametri e flusso di esecuzione:

  • 0 — indice della finestra; 33 — RadiobuttonID esatto; 1 - nuovo valore. Sostituisci 33 con ID del tuo gump.
var ok = UO.NumGumpRadiobutton(0, 33, 1);
if (Truth(ok == 0))
{
    UO.Print("Control missing or value rejected");
}

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

2. Cancella valore - Funzione script

Parametri e flusso di esecuzione:

  • 0 cancella il campo o lo deseleziona. Viene restituito l'esito positivo della modifica, non il nuovo valore del campo.
return  RunScenario();
 object? RunScenario()
{
    var ok = UO.NumGumpRadiobutton(0, 33, 0);
    UO.Print(Convert.ToString(ok));
    return null;
}

3. Compila prima di rispondere - Classe di script

Parametri e flusso di esecuzione:

  • 100 - esempio di conferma ButtonID del server; deve essere sostituito ID della tua finestra. Da 0 a SendGumpSelect(0,100) è l'indice della finestra.
  • La risposta può chiudere il gump e cambiare gli indici. inviato significa invio locale, risultato di un'operazione non confermata dal server.
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()
    {
        if (Truth(UO.NumGumpRadiobutton(0, 33, 1)))
        {
            var sent = UO.SendGumpSelect(0, 100);
            UO.Print(Convert.ToString(sent));
        }

        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.NumGumpRadiobutton(gumpIndex, radiobuttonID, value) — UO.NumGumpRadiobutton(Any,Any,Any)

Parametri: gumpIndex (Any), radiobuttonID (Any), value (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "numgumpradiobutton": return SetIndexedGumpValue(Arg(0), "radio", Arg(1), Text(2));

UO.NumGumpTextEntry

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

Firme C#

int UO.NumGumpTextEntry(object? gumpIndex, object? textEntryID, object? value);

Imposta il testo del campo di input nel server gump per indice.

Parametri

  • gumpIndex — Obbligatorio int — indice del server attivo gump, da 0 a GetGumpsCount()-1. Questo non è GumpID/serial. Il numero negativo e l'indice fuori dall'elenco non sono validi. L'apertura, la chiusura e il riordino delle finestre possono modificare l'indice; controlla GetGumpID/GetGumpSerial prima di agire.
  • textEntryID - int - l'esatto elemento ID dalla descrizione del gump. Questo non è il numero di serie dell'elemento; la ID mancante non viene sostituita con un indice.
  • value - string - nuovo testo. Una stringa vuota cancella il campo; le restrizioni di lunghezza/carattere sul campo stesso vengono mantenute.

Valore restituito

int (bool) — 1, se l'elemento richiesto viene trovato e il suo valore finale corrisponde a quello specificato; 0 se l'indice non è valido, manca il tipo ID/elemento, oppure se il campo non ha assunto un valore esatto. Anche la reimpostazione di un valore già impostato ha esito positivo.

Il risultato del comando è un flag numerico: 1 significa una condizione soddisfatta, 0 significa una condizione non soddisfatta. Dopo var risultato = comando(...) controlla se (risultato != 0) o se (risultato == 0). Salva il risultato di una chiamata: una chiamata ripetuta può eseguire nuovamente l'azione o leggere lo stato che è già cambiato.

Comportamento

  • Funziona con gump server attivi. Zaino, mappa, impostazioni e altre finestre locali non sono incluse in questo elenco. Una chiamata legge i dati nel thread del gioco; chiamate diverse possono visualizzare stati diversi dell'elenco.
  • Cambia lo stato locale. I campi e i pulsanti di opzione selezionati vengono inviati seguiti dalla risposta del pulsante.
  • La selezione di un pulsante di opzione deseleziona il pulsante di opzione adiacente dello stesso gruppo; le caselle di controllo regolari sono indipendenti.

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 risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

var result = UO.NumGumpTextEntry(0, 33, "500");
UO.Print("NumGumpTextEntry: " + Convert.ToString(result));

1. Imposta il valore e controlla il risultato: script diretto

Parametri e flusso di esecuzione:

  • 0 — indice della finestra; 33 — esatto TextEntryID; '500' è il nuovo valore. Sostituisci 33 con ID del tuo gump.
var ok = UO.NumGumpTextEntry(0, 33, "500");
if (Truth(ok == 0))
{
    UO.Print("Control missing or value rejected");
}

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

2. Cancella valore - Funzione script

Parametri e flusso di esecuzione:

  • '' cancella il campo o lo deseleziona. Viene restituito l'esito positivo della modifica, non il nuovo valore del campo.
return  RunScenario();
 object? RunScenario()
{
    var ok = UO.NumGumpTextEntry(0, 33, "");
    UO.Print(Convert.ToString(ok));
    return null;
}

3. Compila prima di rispondere - Classe di script

Parametri e flusso di esecuzione:

  • 100 - esempio di conferma ButtonID del server; deve essere sostituito ID della tua finestra. Da 0 a SendGumpSelect(0,100) è l'indice della finestra.
  • La risposta può chiudere il gump e cambiare gli indici. inviato significa invio locale, risultato di un'operazione non confermata dal server.
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()
    {
        if (Truth(UO.NumGumpTextEntry(0, 33, "500")))
        {
            var sent = UO.SendGumpSelect(0, 100);
            UO.Print(Convert.ToString(sent));
        }

        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.NumGumpTextEntry(gumpIndex, textEntryID, value) — UO.NumGumpTextEntry(Any,Any,Any)

Parametri: gumpIndex (Any), textEntryID (Any), value (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "numgumptextentry": return SetIndexedGumpValue(Arg(0), "textentry", Arg(1), Text(2));

UO.SelectGump

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

Firme C#

void UO.SelectGump(object? id);

Seleziona un server gump esistente per le chiamate successive.

Parametri

  • id - int: corrisponde prima a LocalSerial o ServerSerial, quindi indicizza zero nell'elenco gumps corrente. Questi non sono pulsanti ID.

Valore restituito

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

Comportamento

  • Bridge.SelectGump salva _selectedServerGump. Se serial non corrisponde, prende l'indice 0..count-1. Non trovato: il gump selezionato diventa null e viene visualizzato un messaggio.
  • Gump non si apre e non viene inviata alcuna risposta al server. Gli indici cambiano quando le finestre vengono aperte/chiuse; per una selezione stabile utilizzare l'attuale serial/id.

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.SelectGump");
UO.SelectGump(0);

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Seleziona un server gump esistente per le chiamate successive.
if (Truth(UO.GumpExists(0)))
{
    UO.SelectGump(0);
}

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

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • Bridge.SelectGump salva _selectedServerGump. Se serial non corrisponde, prende l'indice 0..count-1. Non trovato: il gump selezionato diventa null e viene visualizzato un messaggio.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.GetGumpsCount() > 0))
    {
        var serial = UO.GetGumpSerial(0);
        UO.SelectGump(serial);
    }

    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. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

  • Gump non si apre e non viene inviata alcuna risposta al server. Gli indici cambiano quando le finestre vengono aperte/chiuse; per una selezione stabile utilizzare l'attuale serial/id.
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()
    {
        if (Truth(UO.GetGumpsCount() > 0))
        {
            UO.SelectGump(0);
            UO.Print(UO.LastGump("gumpid"));
        }

        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.SelectGump(id) — UO.SelectGump(Any)

Parametri: id (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public void SelectGump(InjectionValue id) => bridge.SelectGump(NumberConversions.ToInt(id));

UO.SendGumpSelect

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

Firme C#

int UO.SendGumpSelect(object? triggerId);
int UO.SendGumpSelect(object? gumpIndex, object? triggerId);
int UO.SendGumpSelect(object? serial, object? gumpId, object? triggerId);
int UO.SendGumpSelect(object? serial, object? gumpId, object? triggerId, object? timeout);

Invia il ButtonID per il server gump selezionato.

Parametri

  • triggerId - int o stringa numerica - ButtonID del server. 0 solitamente significa chiusura/fallimento, ma l'azione esatta è determinata dal server. Non è richiesto un ButtonID visibile nell'albero.
  • gumpIndex — Obbligatorio int — indice del server attivo gump, da 0 a GetGumpsCount()-1. Questo non è GumpID/serial. Il numero negativo e l'indice fuori dall'elenco non sono validi. L'apertura, la chiusura e il riordino delle finestre possono modificare l'indice; controlla GetGumpID/GetGumpSerial prima di agire. Utilizzato solo nella forma a due argomenti (gumpIndex, triggerId).
  • serial — Nelle forme argomento 3/4, il bit numerico 32 serial. 0 o -1 disabilita il filtro serial; i restanti numeri, compresi quelli negativi con il bit più significativo, vengono confrontati esattamente.
  • gumpId — Nei moduli argomento 3/4, il GumpID numerico a 32-bit. 0 o -1 disabilita il filtro GumpID. Sono consentite stringhe esadecimali; i nomi AddObject non sono consentiti qui.
  • timeout — Quarto argomento facoltativo, int millisecondi di attesa per una coppia ID corrispondente. Per impostazione predefinita, 0 è un tentativo immediato; il negativo è limitato a 0. Ricontrollare l'intervallo 20 ms.

Valore restituito

int — 1, se viene trovato un gump del server live e viene richiamata la risposta; 0 se la finestra non viene trovata prima della scadenza del timeout. Non restituisce il ID selezionato e non attende la conferma del risultato da parte del server.

Comportamento

  • Funziona con gump server attivi. Zaino, mappa, impostazioni e altre finestre locali non sono incluse in questo elenco. Una chiamata legge i dati nel thread del gioco; chiamate diverse possono visualizzare stati diversi dell'elenco.
  • Un argomento seleziona il gump precedentemente selezionato da questo script; se è chiuso/non selezionato - l'ultimo elemento dell'elenco corrente. Due argomenti specificano un indice rigoroso. Tre/quattro - una coppia di ID con filtri.
  • La selezione e la chiamata di una risposta avvengono in una richiesta del thread di gioco. L'attesa viene annullata interrompendo la procedura. Non confondere la risposta diretta del server con il cambio di pagina: il pulsante SwitchPage richiede NumGumpButton.

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 risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

var result = UO.SendGumpSelect(100);
UO.Print("SendGumpSelect: " + Convert.ToString(result));

1. Rispondi alla finestra selezionata - script diretto

Parametri e flusso di esecuzione:

  • SelectGump seleziona il tipo/serial 0x12345678 oppure segnala assenza; 100 - ID pulsante.
  • Se non c'è più una finestra selezionata, il modulo con un argomento utilizza l'ultima finestra disponibile. Per un'identità rigorosa, utilizzare un modulo con due ID.
UO.SelectGump(0x12345678);
var sent = UO.SendGumpSelect(100);
UO.Print(Convert.ToString(sent));

2. Rispondi alla prima voce dell'elenco - funzione script

Parametri e flusso di esecuzione:

  • 0 — indice, 100 — ButtonID. Questo non è serial=0 e non GumpID=100.
return  RunScenario();
 object? RunScenario()
{
    var sent = UO.SendGumpSelect(0, 100);
    if (Truth(sent == 0))
    {
        UO.Print("No gump at index zero");
    }

    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. Rispondi in modo specifico alla finestra dallo snapshot - classe script

Parametri e flusso di esecuzione:

  • info[0] - serial, info[1] - GumpID, 100 - ButtonID. La modifica dell'indice non reindirizzerà la risposta a un tipo/proprietario diverso.
  • I valori Serial/GumpID 0/-1 sono filtri non vincolati; le coppie identiche non distinguono le istanze riaperte.
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 info = UO.GetGumpInfo(0);
        if (Truth(ArrayLength(info) == 5))
        {
            var sent = UO.SendGumpSelect(info[0], info[1], 100);
        }

        return null;
    }

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

4. Aspettatevi un tipo specifico: script diretto

Parametri e flusso di esecuzione:

  • 0 disabilita il filtro serial; 0x87654321 — esatto ID con il bit più significativo; 100 — pulsante; 2000 — attesa massima in ms. Non utilizzato come carattere jolly incondizionato.
var sent = UO.SendGumpSelect(0, 0x87654321, 100, 2000);
UO.Print(Convert.ToString(sent));

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.SendGumpSelect(triggerId) — UO.SendGumpSelect(Integer)

Parametri: triggerId (Integer/String)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int SendGumpSelect(int triggerId) => bridge.SendGumpSelect(triggerId);

UO.SendGumpSelect(triggerId) — UO.SendGumpSelect(String)

Parametri: triggerId (Integer/String)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int SendGumpSelect(string triggerId) => SendGumpSelect(NumberConversions.ToInt(triggerId));

UO.SendGumpSelect(gumpIndex, triggerId) — UO.SendGumpSelect(Any,Any)

Parametri: gumpIndex (Any), triggerId (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int SendGumpSelect(InjectionValue gumpIndex, InjectionValue triggerId)

            => bridge.SendGumpSelect(NumberConversions.ToInt(gumpIndex), NumberConversions.ToInt(triggerId));

UO.SendGumpSelect(serial, gumpId, triggerId) — UO.SendGumpSelect(Any,Any,Any)

Parametri: serial (Any), gumpId (Any), triggerId (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int SendGumpSelect(InjectionValue serial, InjectionValue gumpId, InjectionValue triggerId)

            => bridge.SendGumpSelect(NumberConversions.ToInt(serial), NumberConversions.ToInt(gumpId), NumberConversions.ToInt(triggerId));

UO.SendGumpSelect(serial, gumpId, triggerId, timeout) — UO.SendGumpSelect(Any,Any,Any,Any)

Parametri: serial (Any), gumpId (Any), triggerId (Any), timeout (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int SendGumpSelect(InjectionValue serial, InjectionValue gumpId, InjectionValue triggerId, InjectionValue timeout)

            => bridge.SendGumpSelect(NumberConversions.ToInt(serial), NumberConversions.ToInt(gumpId),

                NumberConversions.ToInt(triggerId), Math.Max(0, NumberConversions.ToInt(timeout)));

UO.SetGump

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

Firme C#

void UO.SetGump(object? identifier, object? key, object? stateValue);
void UO.SetGump(object? gumpId, object? identifier, object? key, object? stateValue);

Modifica il campo di un server gump esistente.

Parametri

  • gumpId - Solo forma a quattro argomenti: serial/id o indice Gump zero. Il modulo con tre usi -1 - l'ultimo/gump selezionato.
  • identifier — Stringa "checkbox", "radio" o "textentry", maiuscole e minuscole non sono importanti. Un nome non supportato non modifica il campo.
  • key - int: primo elemento LocalSerial/ID, quindi indice zero tra gli elementi del tipo specificato. Nessun elemento: messaggio di errore.
  • stateValue — Per casella di controllo/radio: "checked", "true" senza distinzione tra maiuscole e minuscole o int riconosciuti diversi da zero; l'altro si spegne. Per l'immissione di testo: tutto il testo fino a ToString.

Valore restituito

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

Comportamento

  • SetGumpValue chiama TrySetGumpValue; con 0 visualizza un messaggio. Cambia il campo locale di un gump già esistente e non registra un hook in attesa di una nuova finestra.
  • La modifica della casella di controllo/immissione di testo non invia automaticamente una risposta al server. Per rispondere selezionare il pulsante tramite SendGumpSelect/WaitGump; I pulsanti di opzione vengono elaborati in una vista separata.

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.SetGump");
UO.SetGump("checkbox", 0, 1);

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Modifica il campo di un server gump esistente.
if (Truth(UO.GetGumpsCount() > 0))
{
    UO.SetGump("checkbox", 0, 1);
}

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

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • SetGumpValue chiama TrySetGumpValue; con 0 visualizza un messaggio. Cambia il campo locale di un gump già esistente e non registra un hook in attesa di una nuova finestra.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.GetGumpsCount() > 0))
    {
        UO.SetGump(0, "textentry", 0, "Example");
    }

    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. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

  • La modifica della casella di controllo/immissione di testo non invia automaticamente una risposta al server. Per rispondere selezionare il pulsante tramite SendGumpSelect/WaitGump; I pulsanti di opzione vengono elaborati in una vista separata.
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()
    {
        if (Truth(UO.GetGumpsCount() > 0))
        {
            UO.SetGump("radio", 0, "true");
            UO.SetGump("checkbox", 0, 0);
        }

        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.SetGump(identifier, key, stateValue) — UO.SetGump(Any,Any,Any)

Parametri: identifier (Any), key (Any), stateValue (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public void SetGump(InjectionValue identifier, InjectionValue key, InjectionValue stateValue)

            => bridge.SetGumpValue(-1, identifier.ToString(), NumberConversions.ToInt(key), stateValue.ToString());

UO.SetGump(gumpId, identifier, key, stateValue) — UO.SetGump(Any,Any,Any,Any)

Parametri: gumpId (Any), identifier (Any), key (Any), stateValue (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public void SetGump(InjectionValue gumpId, InjectionValue identifier, InjectionValue key, InjectionValue stateValue)

            => bridge.SetGumpValue(NumberConversions.ToInt(gumpId), identifier.ToString(), NumberConversions.ToInt(key), stateValue.ToString());

UO.WaitGump

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

Firme C#

void UO.WaitGump(object? value);
void UO.WaitGump(object? trigger1, object? trigger2);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6, object? trigger7);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6, object? trigger7, object? trigger8);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6, object? trigger7, object? trigger8, object? trigger9);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6, object? trigger7, object? trigger8, object? trigger9, object? trigger10);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6, object? trigger7, object? trigger8, object? trigger9, object? trigger10, object? trigger11);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6, object? trigger7, object? trigger8, object? trigger9, object? trigger10, object? trigger11, object? trigger12);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6, object? trigger7, object? trigger8, object? trigger9, object? trigger10, object? trigger11, object? trigger12, object? trigger13);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6, object? trigger7, object? trigger8, object? trigger9, object? trigger10, object? trigger11, object? trigger12, object? trigger13, object? trigger14);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6, object? trigger7, object? trigger8, object? trigger9, object? trigger10, object? trigger11, object? trigger12, object? trigger13, object? trigger14, object? trigger15);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6, object? trigger7, object? trigger8, object? trigger9, object? trigger10, object? trigger11, object? trigger12, object? trigger13, object? trigger14, object? trigger15, object? trigger16);

Registra una sequenza di risposte singole ai pulsanti. L'esecuzione dello script continua immediatamente; l'assenza di una finestra non causa un ritardo di 30 secondi.

Parametri

  • value — Elemento di sequenza: int ButtonID, numerico string, stringa con |/virgola o array di tali elementi. L'ordine è da sinistra a destra. Si applicano i limiti e le regole generali triggerId. Valore è il nome dell'unico parametro nella forma object?, che accetta anche un array.
  • trigger1 — Elemento di sequenza: int ButtonID, numerico string, stringa con |/virgola o array di tali elementi. L'ordine è da sinistra a destra. Si applicano i limiti e le regole generali triggerId. Valore è il nome dell'unico parametro nella forma object?, che accetta anche un array.
  • trigger2 — Elemento di sequenza: int ButtonID, numerico string, stringa con |/virgola o array di tali elementi. L'ordine è da sinistra a destra. Si applicano i limiti e le regole generali triggerId. Valore è il nome dell'unico parametro nella forma object?, che accetta anche un array.
  • trigger3 — Elemento di sequenza: int ButtonID, numerico string, stringa con |/virgola o array di tali elementi. L'ordine è da sinistra a destra. Si applicano i limiti e le regole generali triggerId. Valore è il nome dell'unico parametro nella forma object?, che accetta anche un array.
  • trigger4 — Elemento di sequenza: int ButtonID, numerico string, stringa con |/virgola o array di tali elementi. L'ordine è da sinistra a destra. Si applicano i limiti e le regole generali triggerId. Valore è il nome dell'unico parametro nella forma object?, che accetta anche un array.
  • trigger5 — Elemento di sequenza: int ButtonID, numerico string, stringa con |/virgola o array di tali elementi. L'ordine è da sinistra a destra. Si applicano i limiti e le regole generali triggerId. Valore è il nome dell'unico parametro nella forma object?, che accetta anche un array.
  • trigger6 — Elemento di sequenza: int ButtonID, numerico string, stringa con |/virgola o array di tali elementi. L'ordine è da sinistra a destra. Si applicano i limiti e le regole generali triggerId. Valore è il nome dell'unico parametro nella forma object?, che accetta anche un array.
  • trigger7 — Elemento di sequenza: int ButtonID, numerico string, stringa con |/virgola o array di tali elementi. L'ordine è da sinistra a destra. Si applicano i limiti e le regole generali triggerId. Valore è il nome dell'unico parametro nella forma object?, che accetta anche un array.
  • trigger8 — Elemento di sequenza: int ButtonID, numerico string, stringa con |/virgola o array di tali elementi. L'ordine è da sinistra a destra. Si applicano i limiti e le regole generali triggerId. Valore è il nome dell'unico parametro nella forma object?, che accetta anche un array.
  • trigger9 — Elemento di sequenza: int ButtonID, numerico string, stringa con |/virgola o array di tali elementi. L'ordine è da sinistra a destra. Si applicano i limiti e le regole generali triggerId. Valore è il nome dell'unico parametro nella forma object?, che accetta anche un array.
  • trigger10 — Elemento di sequenza: int ButtonID, numerico string, stringa con |/virgola o array di tali elementi. L'ordine è da sinistra a destra. Si applicano i limiti e le regole generali triggerId. Valore è il nome dell'unico parametro nella forma object?, che accetta anche un array.
  • trigger11 — Elemento di sequenza: int ButtonID, numerico string, stringa con |/virgola o array di tali elementi. L'ordine è da sinistra a destra. Si applicano i limiti e le regole generali triggerId. Valore è il nome dell'unico parametro nella forma object?, che accetta anche un array.
  • trigger12 — Elemento di sequenza: int ButtonID, numerico string, stringa con |/virgola o array di tali elementi. L'ordine è da sinistra a destra. Si applicano i limiti e le regole generali triggerId. Valore è il nome dell'unico parametro nella forma object?, che accetta anche un array.
  • trigger13 — Elemento di sequenza: int ButtonID, numerico string, stringa con |/virgola o array di tali elementi. L'ordine è da sinistra a destra. Si applicano i limiti e le regole generali triggerId. Valore è il nome dell'unico parametro nella forma object?, che accetta anche un array.
  • trigger14 — Elemento di sequenza: int ButtonID, numerico string, stringa con |/virgola o array di tali elementi. L'ordine è da sinistra a destra. Si applicano i limiti e le regole generali triggerId. Valore è il nome dell'unico parametro nella forma object?, che accetta anche un array.
  • trigger15 — Elemento di sequenza: int ButtonID, numerico string, stringa con |/virgola o array di tali elementi. L'ordine è da sinistra a destra. Si applicano i limiti e le regole generali triggerId. Valore è il nome dell'unico parametro nella forma object?, che accetta anche un array.
  • trigger16 — Elemento di sequenza: int ButtonID, numerico string, stringa con |/virgola o array di tali elementi. L'ordine è da sinistra a destra. Si applicano i limiti e le regole generali triggerId. Valore è il nome dell'unico parametro nella forma object?, che accetta anche un array.

Valore restituito

void - non restituisce nulla: né successo, né un nuovo valore, né conferma del server.

Comportamento

  • Cerca un vero pulsante di attivazione con il ButtonID desiderato; I pulsanti per cambiare pagina e finestra senza il pulsante richiesto vengono saltati. I successivi ID non bypassano il primo in attesa. Per una consegna di markup: non più di una risposta in una finestra. Il markup aggiornato può utilizzare lo stesso oggetto finestra.
  • Il successivo WaitGump dello stesso script completa la sequenza in sospeso. La ricerca non è limitata al GumpID: usa NumGumpButton o SendGumpSelect per una selezione precisa. ButtonID=0 funzionerà solo se esiste un pulsante di attivazione esistente con ID 0; Questa non è una chiusura universale.
  • Il normale completamento della procedura risparmia l'attesa. Cancellando il titolare o Terminate con il suo nome si tolgono le sue attese; TerminateAll cancella tutto, compresi quelli rimasti dopo il completamento delle procedure. Cambiare il mondo cancella la coda. Le aspettative non vengono salvate nel profilo.

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.WaitGump");
UO.WaitGump(100);

1. Una risposta: sceneggiatura diretta

Parametri e flusso di esecuzione:

  • 100 — ButtonID della risposta. WaitGump lo registra prima di UseObject; un'ulteriore esecuzione non significa che il server abbia già accettato la risposta.
UO.WaitGump(100);
UO.UseObject("0x40001234");

2. Passaggi multipli: funzione script

Parametri e flusso di esecuzione:

  • 7, 22 e 1 sono i ButtonID dei moduli sequenziali. Questi ID vengono controllati in ordine. Il numero di argomenti non specifica il ritardo; la chiamata registra l'intera sequenza.
return  RunScenario();
 object? RunScenario()
{
    UO.WaitGump(7, 22, 1);
    UO.UseObject("0x40001234");
    return null;
}

3. Annulla aspettative - Classe di script

Parametri e flusso di esecuzione:

  • La riga 7|22|1 specifica la stessa sequenza. TerminateAll cancella quindi tutti i gump pendenti e interrompe tutte le procedure; questa è un'azione globale.
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.WaitGump("7|22|1");
        UO.TerminateAll();
        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.WaitGump(value) — UO.WaitGump(Any)

Parametri: value (Any/Integer/String)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "waitgump": CompactWaitGump(arguments); return InjectionValue.Unit;

UO.WaitGump(value) — UO.WaitGump(Integer)

Parametri: value (Any/Integer/String)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public void WaitGump(int triggerId)

        {

            if (bridge is IApiGumpAutomation automation) automation.QueueGumpButtons(new[] { triggerId });

            else bridge.WaitGumpSelect(triggerId, 30_000);

        }

UO.WaitGump(value) — UO.WaitGump(String)

Parametri: value (Any/Integer/String)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public void WaitGump(string triggerId)

        {

            string text = (triggerId ?? string.Empty).Trim();

            if (text.Contains('|') || text.Contains(','))

            {

                InjectionValue[] chain = text.Split(new[] { '|', ',' }, StringSplitOptions.RemoveEmptyEntries)

                    .Select(value => new InjectionValue(value.Trim())).ToArray();

                CompactWaitGump(chain);

                return;

            }

            WaitGump(NumberConversions.ToInt(triggerId));

        }

UO.WaitGump(trigger1, trigger2) — UO.WaitGump(Any,Any)

Parametri: trigger1 (Any), trigger2 (Any)

Risultato: void / Unit.

Durante la chiamata:

La chiamata esegue il delegate del gestore memorizzato. Il metodo di registrazione lo crea durante la costruzione dell’API.

Codice interno di implementazione; non è uno script autonomo.

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

UO.WaitGump(trigger1, trigger2, trigger3) — UO.WaitGump(Any,Any,Any)

Parametri: trigger1 (Any), trigger2 (Any), trigger3 (Any)

Risultato: void / Unit.

Durante la chiamata:

La chiamata esegue il delegate del gestore memorizzato. Il metodo di registrazione lo crea durante la costruzione dell’API.

Codice interno di implementazione; non è uno script autonomo.

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

UO.WaitGump(trigger1, trigger2, trigger3, trigger4) — UO.WaitGump(Any,Any,Any,Any)

Parametri: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any)

Risultato: void / Unit.

Durante la chiamata:

La chiamata esegue il delegate del gestore memorizzato. Il metodo di registrazione lo crea durante la costruzione dell’API.

Codice interno di implementazione; non è uno script autonomo.

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5) — UO.WaitGump(Any,Any,Any,Any,Any)

Parametri: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any), trigger5 (Any)

Risultato: void / Unit.

Durante la chiamata:

La chiamata esegue il delegate del gestore memorizzato. Il metodo di registrazione lo crea durante la costruzione dell’API.

Codice interno di implementazione; non è uno script autonomo.

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6) — UO.WaitGump(Any,Any,Any,Any,Any,Any)

Parametri: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any), trigger5 (Any), trigger6 (Any)

Risultato: void / Unit.

Durante la chiamata:

La chiamata esegue il delegate del gestore memorizzato. Il metodo di registrazione lo crea durante la costruzione dell’API.

Codice interno di implementazione; non è uno script autonomo.

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6, trigger7) — UO.WaitGump(Any,Any,Any,Any,Any,Any,Any)

Parametri: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any), trigger5 (Any), trigger6 (Any), trigger7 (Any)

Risultato: void / Unit.

Durante la chiamata:

La chiamata esegue il delegate del gestore memorizzato. Il metodo di registrazione lo crea durante la costruzione dell’API.

Codice interno di implementazione; non è uno script autonomo.

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6, trigger7, trigger8) — UO.WaitGump(Any,Any,Any,Any,Any,Any,Any,Any)

Parametri: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any), trigger5 (Any), trigger6 (Any), trigger7 (Any), trigger8 (Any)

Risultato: void / Unit.

Durante la chiamata:

La chiamata esegue il delegate del gestore memorizzato. Il metodo di registrazione lo crea durante la costruzione dell’API.

Codice interno di implementazione; non è uno script autonomo.

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6, trigger7, trigger8, trigger9) — UO.WaitGump(Any,Any,Any,Any,Any,Any,Any,Any,Any)

Parametri: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any), trigger5 (Any), trigger6 (Any), trigger7 (Any), trigger8 (Any), trigger9 (Any)

Risultato: void / Unit.

Durante la chiamata:

La chiamata esegue il delegate del gestore memorizzato. Il metodo di registrazione lo crea durante la costruzione dell’API.

Codice interno di implementazione; non è uno script autonomo.

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6, trigger7, trigger8, trigger9, trigger10) — UO.WaitGump(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)

Parametri: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any), trigger5 (Any), trigger6 (Any), trigger7 (Any), trigger8 (Any), trigger9 (Any), trigger10 (Any)

Risultato: void / Unit.

Durante la chiamata:

La chiamata esegue il delegate del gestore memorizzato. Il metodo di registrazione lo crea durante la costruzione dell’API.

Codice interno di implementazione; non è uno script autonomo.

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6, trigger7, trigger8, trigger9, trigger10, trigger11) — UO.WaitGump(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)

Parametri: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any), trigger5 (Any), trigger6 (Any), trigger7 (Any), trigger8 (Any), trigger9 (Any), trigger10 (Any), trigger11 (Any)

Risultato: void / Unit.

Durante la chiamata:

La chiamata esegue il delegate del gestore memorizzato. Il metodo di registrazione lo crea durante la costruzione dell’API.

Codice interno di implementazione; non è uno script autonomo.

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6, trigger7, trigger8, trigger9, trigger10, trigger11, trigger12) — UO.WaitGump(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)

Parametri: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any), trigger5 (Any), trigger6 (Any), trigger7 (Any), trigger8 (Any), trigger9 (Any), trigger10 (Any), trigger11 (Any), trigger12 (Any)

Risultato: void / Unit.

Durante la chiamata:

La chiamata esegue il delegate del gestore memorizzato. Il metodo di registrazione lo crea durante la costruzione dell’API.

Codice interno di implementazione; non è uno script autonomo.

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6, trigger7, trigger8, trigger9, trigger10, trigger11, trigger12, trigger13) — UO.WaitGump(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)

Parametri: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any), trigger5 (Any), trigger6 (Any), trigger7 (Any), trigger8 (Any), trigger9 (Any), trigger10 (Any), trigger11 (Any), trigger12 (Any), trigger13 (Any)

Risultato: void / Unit.

Durante la chiamata:

La chiamata esegue il delegate del gestore memorizzato. Il metodo di registrazione lo crea durante la costruzione dell’API.

Codice interno di implementazione; non è uno script autonomo.

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6, trigger7, trigger8, trigger9, trigger10, trigger11, trigger12, trigger13, trigger14) — UO.WaitGump(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)

Parametri: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any), trigger5 (Any), trigger6 (Any), trigger7 (Any), trigger8 (Any), trigger9 (Any), trigger10 (Any), trigger11 (Any), trigger12 (Any), trigger13 (Any), trigger14 (Any)

Risultato: void / Unit.

Durante la chiamata:

La chiamata esegue il delegate del gestore memorizzato. Il metodo di registrazione lo crea durante la costruzione dell’API.

Codice interno di implementazione; non è uno script autonomo.

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6, trigger7, trigger8, trigger9, trigger10, trigger11, trigger12, trigger13, trigger14, trigger15) — UO.WaitGump(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)

Parametri: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any), trigger5 (Any), trigger6 (Any), trigger7 (Any), trigger8 (Any), trigger9 (Any), trigger10 (Any), trigger11 (Any), trigger12 (Any), trigger13 (Any), trigger14 (Any), trigger15 (Any)

Risultato: void / Unit.

Durante la chiamata:

La chiamata esegue il delegate del gestore memorizzato. Il metodo di registrazione lo crea durante la costruzione dell’API.

Codice interno di implementazione; non è uno script autonomo.

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6, trigger7, trigger8, trigger9, trigger10, trigger11, trigger12, trigger13, trigger14, trigger15, trigger16) — UO.WaitGump(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)

Parametri: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any), trigger5 (Any), trigger6 (Any), trigger7 (Any), trigger8 (Any), trigger9 (Any), trigger10 (Any), trigger11 (Any), trigger12 (Any), trigger13 (Any), trigger14 (Any), trigger15 (Any), trigger16 (Any)

Risultato: void / Unit.

Durante la chiamata:

La chiamata esegue il delegate del gestore memorizzato. Il metodo di registrazione lo crea durante la costruzione dell’API.

Codice interno di implementazione; non è uno script autonomo.

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

UO.WaitGumpCheck

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

Firme C#

void UO.WaitGumpCheck(object? index, object? state);
void UO.WaitGumpCheck(object? index, object? state, object? index2, object? state2);
void UO.WaitGumpCheck(object? index, object? state, object? index2, object? state2, object? index3, object? state3);

Modifica fino a tre campi della casella di controllo del gump corrente.

Parametri

  • index — int elemento ID o indice zero, come SetGump. Gli argomenti sono forniti in coppia: selettore, valore.
  • index2 — int elemento ID o indice zero, come SetGump. Gli argomenti sono forniti in coppia: selettore, valore.
  • index3 — int elemento ID o indice zero, come SetGump. Gli argomenti sono forniti in coppia: selettore, valore.
  • state — Valore del campo fino a ToString. La casella di controllo include il numero "selezionato"/"true"/diverso da zero; textentry accetta il testo.
  • state2 — Valore del campo fino a ToString. La casella di controllo include il numero "selezionato"/"true"/diverso da zero; textentry accetta il testo.
  • state3 — Valore del campo fino a ToString. La casella di controllo include il numero "selezionato"/"true"/diverso da zero; textentry accetta il testo.

Valore restituito

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

Comportamento

  • ExecuteLegacyManualAlias esamina gli argomenti in coppia e chiama SetGumpValue(-1, "checkbox", selettore, valore) per ognuno. Tutti i moduli registrati sono argomenti 2, 4 o 6.
  • Il nome UO.Wait non significa attesa: non c'è blocco né coda per futuri gump. Se il campo manca, viene visualizzato un errore. La risposta del pulsante non viene inviata.

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.WaitGumpCheck");
UO.WaitGumpCheck(0, 1);

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Modifica fino a tre campi della casella di controllo del gump corrente.
if (Truth(UO.GetGumpsCount() > 0))
{
    UO.WaitGumpCheck(0, 1);
}

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

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • ExecuteLegacyManualAlias esamina gli argomenti in coppia e chiama SetGumpValue(-1, "checkbox", selettore, valore) per ognuno. Tutti i moduli registrati sono argomenti 2, 4 o 6.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.GetGumpsCount() > 0))
    {
        UO.WaitGumpCheck(0, 1, 1, 0);
    }

    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. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

  • Il nome UO.Wait non significa attesa: non c'è blocco né coda per futuri gump. Se il campo manca, viene visualizzato un errore. La risposta del pulsante non viene inviata.
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()
    {
        if (Truth(UO.GetGumpsCount() > 0))
        {
            UO.WaitGumpCheck(0, 1, 1, 0, 2, 1);
        }

        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.WaitGumpCheck(index, state) — UO.WaitGumpCheck(Any,Any)

Parametri: index (Any), state (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "waitgumpcheck":

                    for (int index = 0; index + 1 < arguments.Length; index += 2)

                        bridge.SetGumpValue(-1, "checkbox", Arg(index), Text(index + 1));

                    break;

UO.WaitGumpCheck(index, state, index2, state2) — UO.WaitGumpCheck(Any,Any,Any,Any)

Parametri: index (Any), state (Any), index2 (Any), state2 (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "waitgumpcheck":

                    for (int index = 0; index + 1 < arguments.Length; index += 2)

                        bridge.SetGumpValue(-1, "checkbox", Arg(index), Text(index + 1));

                    break;

UO.WaitGumpCheck(index, state, index2, state2, index3, state3) — UO.WaitGumpCheck(Any,Any,Any,Any,Any,Any)

Parametri: index (Any), state (Any), index2 (Any), state2 (Any), index3 (Any), state3 (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "waitgumpcheck":

                    for (int index = 0; index + 1 < arguments.Length; index += 2)

                        bridge.SetGumpValue(-1, "checkbox", Arg(index), Text(index + 1));

                    break;

UO.WaitGumpEntry

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

Firme C#

void UO.WaitGumpEntry(object? index, object? text);
void UO.WaitGumpEntry(object? index, object? text, object? index2, object? text2);
void UO.WaitGumpEntry(object? index, object? text, object? index2, object? text2, object? index3, object? text3);

Modifica fino a tre campi di testo del gump corrente.

Parametri

  • index — int elemento ID o indice zero, come SetGump. Gli argomenti sono forniti in coppia: selettore, valore.
  • index2 — int elemento ID o indice zero, come SetGump. Gli argomenti sono forniti in coppia: selettore, valore.
  • index3 — int elemento ID o indice zero, come SetGump. Gli argomenti sono forniti in coppia: selettore, valore.
  • text — Valore del campo fino a ToString. La casella di controllo include il numero "selezionato"/"true"/diverso da zero; textentry accetta il testo.
  • text2 — Valore del campo fino a ToString. La casella di controllo include il numero "selezionato"/"true"/diverso da zero; textentry accetta il testo.
  • text3 — Valore del campo fino a ToString. La casella di controllo include il numero "selezionato"/"true"/diverso da zero; textentry accetta il testo.

Valore restituito

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

Comportamento

  • ExecuteLegacyManualAlias esamina gli argomenti in coppia e chiama SetGumpValue(-1, "textentry", selettore, valore) per ciascuno. Tutti i moduli registrati sono argomenti 2, 4 o 6.
  • Il nome UO.Wait non significa attesa: non c'è blocco né coda per futuri gump. Se il campo manca, viene visualizzato un errore. La risposta del pulsante non viene inviata.

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.WaitGumpEntry");
UO.WaitGumpEntry(0, "Example");

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Modifica fino a tre campi di testo del gump corrente.
if (Truth(UO.GetGumpsCount() > 0))
{
    UO.WaitGumpEntry(0, "Example");
}

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

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • ExecuteLegacyManualAlias esamina gli argomenti in coppia e chiama SetGumpValue(-1, "textentry", selettore, valore) per ciascuno. Tutti i moduli registrati sono argomenti 2, 4 o 6.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.GetGumpsCount() > 0))
    {
        UO.WaitGumpEntry(0, "First", 1, "Second");
    }

    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. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

  • Il nome UO.Wait non significa attesa: non c'è blocco né coda per futuri gump. Se il campo manca, viene visualizzato un errore. La risposta del pulsante non viene inviata.
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()
    {
        if (Truth(UO.GetGumpsCount() > 0))
        {
            UO.WaitGumpEntry(0, "First", 1, "Second", 2, "Third");
        }

        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.WaitGumpEntry(index, text) — UO.WaitGumpEntry(Any,Any)

Parametri: index (Any), text (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "waitgumpentry":

                    for (int index = 0; index + 1 < arguments.Length; index += 2)

                        bridge.SetGumpValue(-1, "textentry", Arg(index), Text(index + 1));

                    break;

UO.WaitGumpEntry(index, text, index2, text2) — UO.WaitGumpEntry(Any,Any,Any,Any)

Parametri: index (Any), text (Any), index2 (Any), text2 (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "waitgumpentry":

                    for (int index = 0; index + 1 < arguments.Length; index += 2)

                        bridge.SetGumpValue(-1, "textentry", Arg(index), Text(index + 1));

                    break;

UO.WaitGumpEntry(index, text, index2, text2, index3, text3) — UO.WaitGumpEntry(Any,Any,Any,Any,Any,Any)

Parametri: index (Any), text (Any), index2 (Any), text2 (Any), index3 (Any), text3 (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "waitgumpentry":

                    for (int index = 0; index + 1 < arguments.Length; index += 2)

                        bridge.SetGumpValue(-1, "textentry", Arg(index), Text(index + 1));

                    break;

ClassicUO — Bad Newbie & C# Scripts IDE

ClassicUO — Bad Newbie & C# Scripts IDE

Clone this wiki locally