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

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

Vecchi menu, menu contestuali e immissione di testo. Questi sono meccanismi separati; prendere il numero della voce dalla risposta del menù desiderato.

UO.AutoMenu · UO.WaitMenu · UO.GetMenuItems · UO.GetMenuItemsEx · UO.GetLastMenuItems · UO.MenuHookPresent · UO.MenuPresent · UO.CancelAllMenuHooks · UO.CancelMenu · UO.CloseMenu · UO.WaitingForMenu · UO.WaitingMenu

UO.GetContextMenu · UO.RequestContextMenu · UO.SetContextMenuHook · UO.ClearContextMenu

UO.WaitTextEntry · UO.ConsoleEntryReply · UO.ConsoleEntryUnicodeReply

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.

Parametri, risultato e tutti gli scenari

var id = UO.GetSerial("lasttarget");
if (Truth(UO.Exists(id)))
{
    UO.RequestContextMenu(id);
}

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

Parametri, risultato e tutti gli scenari

UO.WaitMenu("Craft", "Tools");

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

void UO.AutoMenu(object? prompt, object? choice);

Registra un hook di menu persistente: quando viene visualizzato un menu del server con una didascalia adatta, il client seleziona la voce appropriata. La chiamata non apre il menu e non lo attende in modo sincrono.

• prompt — sottostringa del titolo del menu del server.
• choice — sottostringa della firma della voce di menu.

void. La chiamata registra solo un hook e non segnala se il menu è stato trovato o se la voce è stata selezionata con successo.

• Ogni volta che il client viene aggiornato, l'hook cerca un menu del server che non è stato ancora chiuso e il cui titolo contiene prompt. Se viene trovato un elemento la cui firma contiene choice, il client lo seleziona. L'hook rimane registrato dopo la selezione, quindi funzionerà sui successivi menu di abbinamento. Puoi rimuovere i ganci usando UO.CancelMenu().

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.

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.AutoMenu");
UO.AutoMenu("Choose material", "Copper");

Parametri e flusso di esecuzione:

• Attendi un menu dal titolo "Scegli materiale" e seleziona la voce con il testo "Rame".

UO.AutoMenu("Choose material", "Copper");

Parametri e flusso di esecuzione:

• Le sottostringhe vengono confrontate senza distinzione tra maiuscole e minuscole; l'aggancio influisce anche sui successivi menu abbinati.

return  RunScenario();
 object? RunScenario()
{
    var menuCaption = "choose color";
    var itemCaption = "blue";
    UO.AutoMenu(menuCaption, itemCaption);
    return null;
}

Parametri e flusso di esecuzione:

• Registra un hook per la durata di questa attività, quindi elimina tutti gli hook per questo client.
• È possibile eseguire altre azioni di script prima che venga visualizzato il menu.

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.AutoMenu("Choose material", "Iron");
        UO.CancelMenu();
        return null;
    }
}

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

Parametri: prompt (Any), choice (Any)

Risultato: void / Unit.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.AddMenuHook: bridge.AddMenuHook(arguments[0].ToString(), arguments[1].ToString(), true).
• InjectionScript.Runtime.InjectionValue.ToString: arguments[0].ToString().

Codice interno di implementazione; non è uno script autonomo.

case "automenu":

                    if (arguments.Length >= 2) bridge.AddMenuHook(arguments[0].ToString(), arguments[1].ToString(), true);

                    break;

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

void UO.CancelAllMenuHooks();

Rimuove tutti gli hook automatici registrati dai vecchi menu del server client.

Non ci sono parametri.

void: nessun valore restituito.

• Chiama il direttore ClearMenuHooks. Le regole di selezione singole e persistenti vengono rimosse, incluse AutoMenu e WaitMenu. Questo comando non chiude i menu già aperti; CloseMenu viene utilizzato per questo.

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.

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

Parametri e flusso di esecuzione:

• La rimozione si applica all'intero set di hook del menu client.

UO.CancelAllMenuHooks();

Parametri e flusso di esecuzione:

• Il gancio viene immediatamente rimosso; i menu abbinati futuri non verranno più selezionati automaticamente.

return  RunScenario();
 object? RunScenario()
{
    UO.AutoMenu("Choose material", "Iron");
    UO.CancelAllMenuHooks();
    return null;
}

Parametri e flusso di esecuzione:

• Il primo comando rimuove gli hook; il secondo cancella separatamente i vecchi menù aperti.

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.CancelAllMenuHooks();
        UO.CloseMenu();
        return null;
    }
}

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

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.ClearMenuHooks: bridge.ClearMenuHooks().

Codice interno di implementazione; non è uno script autonomo.

case "cancelallmenuhooks": bridge.ClearMenuHooks(); return InjectionValue.Unit;

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

void UO.CancelMenu();

Rimuove tutti gli hook automatici registrati dai vecchi menu del server client.

Non ci sono parametri.

void: nessun valore restituito.

• Chiama il direttore ClearMenuHooks. Le regole di selezione singole e persistenti vengono rimosse, incluse AutoMenu e WaitMenu. Questo comando non chiude i menu già aperti; CloseMenu viene utilizzato per questo.

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.

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

Parametri e flusso di esecuzione:

• La rimozione si applica all'intero set di hook del menu client.

UO.CancelMenu();

Parametri e flusso di esecuzione:

• Il gancio viene immediatamente rimosso; i menu abbinati futuri non verranno più selezionati automaticamente.

return  RunScenario();
 object? RunScenario()
{
    UO.AutoMenu("Choose material", "Iron");
    UO.CancelMenu();
    return null;
}

Parametri e flusso di esecuzione:

• Il primo comando rimuove gli hook; il secondo cancella separatamente i vecchi menù aperti.

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.CancelMenu();
        UO.CloseMenu();
        return null;
    }
}

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

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.ClearMenuHooks: bridge.ClearMenuHooks().

Codice interno di implementazione; non è uno script autonomo.

case "cancelmenu": bridge.ClearMenuHooks(); break;

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

void UO.ClearContextMenu();

Rimuove il modello di menu contestuale locale corrente.

Non ci sono parametri.

void: nessun valore restituito.

• Chiama Dispose su ServerMenus.Context se esiste un modello; dopo la richiesta successiva potrebbe apparire un nuovo menu del server. Questo non è CloseMenu.

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.

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

Parametri e flusso di esecuzione:

• Rimuove il modello di menu contestuale locale corrente.

UO.ClearContextMenu();

Parametri e flusso di esecuzione:

• Rimuovi il menu contestuale locale dopo aver letto l'istantanea.

return  RunScenario();
 object? RunScenario()
{
    var entries = UO.GetContextMenu();
    UO.ClearContextMenu();
    return null;
}

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.ClearContextMenu();
        UO.ClearContextMenu();
        return null;
    }
}

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

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.ClearContextMenu: bridge.ClearContextMenu().

Codice interno di implementazione; non è uno script autonomo.

case "clearcontextmenu": bridge.ClearContextMenu(); return InjectionValue.Unit;

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

void UO.CloseMenu();

Cancella tutti i menu del vecchio server attivi tramite CancelForYoko.

Non ci sono parametri.

void: nessun valore restituito.

• Scorre lo snapshot ServerMenus ed elimina ogni modello. Non rimuove gli hook automatici dei menu e non chiude finestre gump/interfaccia arbitrarie.

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.

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

Parametri e flusso di esecuzione:

• La cancellazione si applica ai vecchi menu MenuGump/server.

UO.CloseMenu();

Parametri e flusso di esecuzione:

• La selezione automatica e i menu aperti sono gestiti da comandi separati.

return  RunScenario();
 object? RunScenario()
{
    UO.CancelAllMenuHooks();
    UO.CloseMenu();
    return null;
}

Parametri e flusso di esecuzione:

• Un'istantanea dell'elenco viene salvata negli elementi anche dopo aver annullato il menu.

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 items = UO.GetLastMenuItems();
        UO.Print(Convert.ToString(ArrayLength(items)));
        UO.CloseMenu();
        return null;
    }

    int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
}

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

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CloseMenu: bridge.CloseMenu().

Codice interno di implementazione; non è uno script autonomo.

case "closemenu": bridge.CloseMenu(); return InjectionValue.Unit;

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

void UO.ConsoleEntryReply(object? text);

Risponde con testo al prompt del server attivo tramite MessageManager.SendServerPromptResponse.

• text — Il valore da convertire in una stringa. Una stringa vuota viene inviata come risposta vuota.

void: nessun valore restituito.

• Entrambe le squadre si dirigono a ReplyServerPrompt. Il tipo di pacchetto ASCII/Unicode viene selezionato in base allo stato del prompt del server salvato; Il nome del comando non impone una codifica separata. Se non è presente alcuna richiesta attiva, il manager non invia una risposta.

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.

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

Parametri e flusso di esecuzione:

• L'invio si riferisce alla richiesta di input del server corrente.

UO.ConsoleEntryReply("reply");

Parametri e flusso di esecuzione:

• Il testo vuoto viene inviato al manager come risposta vuota.

return  RunScenario();
 object? RunScenario()
{
    UO.ConsoleEntryReply("");
    return null;
}

Parametri e flusso di esecuzione:

• Il nome della variabile non influisce sul formato del prompt del server selezionato.

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 reply = "New item name";
        UO.ConsoleEntryReply(reply);
        return null;
    }
}

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

Parametri: text (Any)

Risultato: void / Unit.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.ReplyServerPrompt: bridge.ReplyServerPrompt(Text(0)).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Text: Text(0).

Codice interno di implementazione; non è uno script autonomo.

case "consoleentryreply":

                case "consoleentryunicodereply": bridge.ReplyServerPrompt(Text(0)); return InjectionValue.Unit;

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

void UO.ConsoleEntryUnicodeReply(object? text);

Risponde con testo al prompt del server attivo tramite MessageManager.SendServerPromptResponse.

• text — Il valore da convertire in una stringa. Una stringa vuota viene inviata come risposta vuota.

void: nessun valore restituito.

• Entrambe le squadre si dirigono a ReplyServerPrompt. Il tipo di pacchetto ASCII/Unicode viene selezionato in base allo stato del prompt del server salvato; Il nome del comando non impone una codifica separata. Se non è presente alcuna richiesta attiva, il manager non invia una risposta.

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.

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

Parametri e flusso di esecuzione:

• L'invio si riferisce alla richiesta di input del server corrente.

UO.ConsoleEntryUnicodeReply("reply");

Parametri e flusso di esecuzione:

• Il testo vuoto viene inviato al manager come risposta vuota.

return  RunScenario();
 object? RunScenario()
{
    UO.ConsoleEntryUnicodeReply("");
    return null;
}

Parametri e flusso di esecuzione:

• Il nome della variabile non influisce sul formato del prompt del server selezionato.

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 reply = "New item name";
        UO.ConsoleEntryUnicodeReply(reply);
        return null;
    }
}

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

Parametri: text (Any)

Risultato: void / Unit.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.ReplyServerPrompt: bridge.ReplyServerPrompt(Text(0)).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Text: Text(0).

Codice interno di implementazione; non è uno script autonomo.

case "consoleentryreply":

                case "consoleentryunicodereply": bridge.ReplyServerPrompt(Text(0)); return InjectionValue.Unit;

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

dynamic UO.GetContextMenu();

Legge le stringhe di elementi del modello di menu contestuale corrente.

Non ci sono parametri.

Array di stringhe da ServerMenus.Context.GetYokoItems(); se non è presente alcun modello, un array vuoto.

• Non invia RequestContextMenu e non attende una risposta dal server. Per ottenere un nuovo menu, richiederlo prima separatamente e attendere la visualizzazione del modello. ClearContextMenu cancella il modello dopo la lettura.

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.

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.GetContextMenu();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

Parametri e flusso di esecuzione:

• Viene letto il modello esistente.

var entries = UO.GetContextMenu();
for (int i = (int)(0); i <= ArrayLength(entries)-1; i += (int)(1))
{
    UO.Print(entries[i]);
}

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;

Parametri e flusso di esecuzione:

• 500 ms - esempio di pausa, non garanzia di risposta del server; un array vuoto è accettabile.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    UO.RequestContextMenu(UO.Self());
    await Delay(500);
    var entries = UO.GetContextMenu();
    UO.Print(Convert.ToString(ArrayLength(entries)));
    return null;
}

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));

Parametri e flusso di esecuzione:

• L'array salvato non scompare dopo aver cancellato il modello di menu.

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 entries = UO.GetContextMenu();
        UO.ClearContextMenu();
        UO.Print(Convert.ToString(ArrayLength(entries)));
        return null;
    }

    int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
}

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

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• InjectionScript.Runtime.InjectionApiUO.StringArray: StringArray(bridge.GetContextMenu()).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetContextMenu: bridge.GetContextMenu().

Codice interno di implementazione; non è uno script autonomo.

case "getcontextmenu": return StringArray(bridge.GetContextMenu());

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

dynamic UO.GetLastMenuItems();

Legge le voci del menu del vecchio server già aperto.

Non ci sono parametri.

Matrice di stringhe. Nome articolo/righe descrittive GetYokoItems. La mancanza di un menu adatto risulta in un array vuoto.

• È selezionato l'ultimo menu foto ServerMenus. Il comando non apre il menu, non inserisce un hook e non seleziona un elemento. Questo non è un menu contestuale o un normale gump del server.
• L'ordine corrisponde ai punti del modello. L'elenco è un'istantanea; le successive modifiche al menu non aggiornano l'array salvato.

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.

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.GetLastMenuItems();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

Parametri e flusso di esecuzione:

• Un array vuoto è sicuro per il ciclo.

var items = UO.GetLastMenuItems();
for (int i = (int)(0); i <= ArrayLength(items)-1; i += (int)(1))
{
    UO.Print(items[i]);
}

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;

Parametri e flusso di esecuzione:

• L'indice 0 viene letto solo dopo aver controllato la dimensione.

return  RunScenario();
 object? RunScenario()
{
    var items = UO.GetLastMenuItems();
    if (Truth(ArrayLength(items) > 0))
    {
        UO.Print(items[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;

Parametri e flusso di esecuzione:

• L'array rimane disponibile dopo aver annullato il menu del 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()
    {
        var items = UO.GetLastMenuItems();
        UO.CloseMenu();
        UO.Print(Convert.ToString(ArrayLength(items)));
        return null;
    }

    int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
}

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

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• InjectionScript.Runtime.InjectionApiUO.StringArray: StringArray(bridge.GetLastMenuItems()).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetLastMenuItems: bridge.GetLastMenuItems().

Codice interno di implementazione; non è uno script autonomo.

case "getlastmenuitems": return StringArray(bridge.GetLastMenuItems());

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

dynamic UO.GetMenuItems(object? caption);

Legge le voci del menu del vecchio server già aperto.

• caption — Sottostringa del titolo del vecchio menu del server; cerca OrdinalIgnoreCase. Una riga vuota corrisponde a qualsiasi intestazione.

Matrice di stringhe. Nome articolo/righe descrittive GetYokoItems. La mancanza di un menu adatto risulta in un array vuoto.

• Viene selezionato l'ultimo menu non eliminato con la sottostringa del titolo corrispondente. Il comando non apre il menu, non inserisce un hook e non seleziona un elemento. Questo non è un menu contestuale o un normale gump del server.
• L'ordine corrisponde ai punti del modello. L'elenco è un'istantanea; le successive modifiche al menu non aggiornano l'array salvato.

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.

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.GetMenuItems("");
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

Parametri e flusso di esecuzione:

• Un array vuoto è sicuro per il ciclo.

var items = UO.GetMenuItems("");
for (int i = (int)(0); i <= ArrayLength(items)-1; i += (int)(1))
{
    UO.Print(items[i]);
}

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;

Parametri e flusso di esecuzione:

• L'indice 0 viene letto solo dopo aver controllato la dimensione.

return  RunScenario();
 object? RunScenario()
{
    var items = UO.GetMenuItems("");
    if (Truth(ArrayLength(items) > 0))
    {
        UO.Print(items[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;

Parametri e flusso di esecuzione:

• L'array rimane disponibile dopo aver annullato il menu del 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()
    {
        var items = UO.GetMenuItems("");
        UO.CloseMenu();
        UO.Print(Convert.ToString(ArrayLength(items)));
        return null;
    }

    int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
}

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

Parametri: caption (Any)

Risultato: dynamic / Any.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• InjectionScript.Runtime.InjectionApiUO.StringArray: StringArray(bridge.GetMenuItems(Text(0), false)).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetMenuItems: bridge.GetMenuItems(Text(0), false).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Text: Text(0).

Codice interno di implementazione; non è uno script autonomo.

case "getmenuitems": return StringArray(bridge.GetMenuItems(Text(0), false));

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

dynamic UO.GetMenuItemsEx(object? caption);

Legge le voci del menu del vecchio server già aperto.

• caption — Sottostringa del titolo del vecchio menu del server; cerca OrdinalIgnoreCase. Una riga vuota corrisponde a qualsiasi intestazione.

Matrice di stringhe. Stringhe graphicHex|hueHex|indice|nome, ad esempio 0x0001|0x0000|1|scelta. La mancanza di un menu adatto risulta in un array vuoto.

• Viene selezionato l'ultimo menu non eliminato con la sottostringa del titolo corrispondente. Il comando non apre il menu, non inserisce un hook e non seleziona un elemento. Questo non è un menu contestuale o un normale gump del server.
• L'ordine corrisponde ai punti del modello. L'elenco è un'istantanea; le successive modifiche al menu non aggiornano l'array salvato.

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.

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.GetMenuItemsEx("");
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

Parametri e flusso di esecuzione:

• Un array vuoto è sicuro per il ciclo.

var items = UO.GetMenuItemsEx("");
for (int i = (int)(0); i <= ArrayLength(items)-1; i += (int)(1))
{
    UO.Print(items[i]);
}

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;

Parametri e flusso di esecuzione:

• L'indice 0 viene letto solo dopo aver controllato la dimensione.

return  RunScenario();
 object? RunScenario()
{
    var items = UO.GetMenuItemsEx("");
    if (Truth(ArrayLength(items) > 0))
    {
        UO.Print(items[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;

Parametri e flusso di esecuzione:

• L'array rimane disponibile dopo aver annullato il menu del 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()
    {
        var items = UO.GetMenuItemsEx("");
        UO.CloseMenu();
        UO.Print(Convert.ToString(ArrayLength(items)));
        return null;
    }

    int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
}

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

Parametri: caption (Any)

Risultato: dynamic / Any.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• InjectionScript.Runtime.InjectionApiUO.StringArray: StringArray(bridge.GetMenuItems(Text(0), true)).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetMenuItems: bridge.GetMenuItems(Text(0), true).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Text: Text(0).

Codice interno di implementazione; non è uno script autonomo.

case "getmenuitemsex": return StringArray(bridge.GetMenuItems(Text(0), true));

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

dynamic UO.MenuHookPresent();

Legge la presenza di ganci di menu registrati.

Non ci sono parametri.

Flag numerico int: 1 - _manager.HasMenuHooks, 0 - nessun hook. Il menu stesso potrebbe ancora mancare.

• Legge la presenza di ganci di menu registrati. Non attende un menu, non controlla il gump del server e non consuma un hook.
• Legge lo stato locale attuale. Non esiste alcun pacchetto, destinazione o aggiornamento automatico; le singole letture possono vedere stati diversi.

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.

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.MenuHookPresent();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

Parametri e flusso di esecuzione:

• Legge la presenza di ganci di menu registrati.

UO.Print(UO.MenuHookPresent());

Parametri e flusso di esecuzione:

• Legge la presenza di ganci di menu registrati. Non attende un menu, non controlla il gump del server e non consuma un hook.

return  RunScenario();
 object? RunScenario()
{
    UO.WaitMenu("Craft", "Tools");
    UO.Print(UO.MenuHookPresent());
    return null;
}

Parametri e flusso di esecuzione:

• Legge lo stato locale attuale. Non esiste alcun pacchetto, destinazione o aggiornamento automatico; le singole letture possono vedere stati 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()
    {
        var before = UO.MenuHookPresent();
        UO.Wait(500);
        var after = UO.MenuHookPresent();
        UO.Print(before);
        UO.Print(after);
        return null;
    }
}

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

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.MenuHookPresent: bridge.MenuHookPresent().

Codice interno di implementazione; non è uno script autonomo.

case "menuhookpresent": return new InjectionValue(bridge.MenuHookPresent());

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

dynamic UO.MenuPresent();

MenuPresent chiama direttamente WaitingMenu.

Non ci sono parametri.

Flag numerico int: 1 - c'è un menu del server, 0 - no.

• MenuPresent chiama direttamente WaitingMenu. Non controlla GetGumpsCount, menu contestuali o hook registrati.
• Legge lo stato locale attuale. Non esiste alcun pacchetto, destinazione o aggiornamento automatico; le singole letture possono vedere stati diversi.

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.

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.MenuPresent();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

Parametri e flusso di esecuzione:

• MenuPresent chiama direttamente WaitingMenu.

UO.Print(UO.MenuPresent());

Parametri e flusso di esecuzione:

• MenuPresent chiama direttamente WaitingMenu. Non controlla GetGumpsCount, menu contestuali o hook registrati.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.MenuPresent()))
    {
        UO.Print(UO.GetLastMenuItems());
    }

    return null;
}

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

Parametri e flusso di esecuzione:

• Legge lo stato locale attuale. Non esiste alcun pacchetto, destinazione o aggiornamento automatico; le singole letture possono vedere stati 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()
    {
        var before = UO.MenuPresent();
        UO.Wait(500);
        var after = UO.MenuPresent();
        UO.Print(before);
        UO.Print(after);
        return null;
    }
}

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

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.MenuPresent: bridge.MenuPresent().

Codice interno di implementazione; non è uno script autonomo.

case "menupresent": return new InjectionValue(bridge.MenuPresent());

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

void UO.RequestContextMenu(object? objID);

Richiede il menu contestuale dell'oggetto.

• objID — Oggetto seriale/ID: int, stringa numerica/esadecimale o alias stabilito, ad esempio "lasttarget". Questo non è graphic/type. Controllare l'oggetto caricato prima di agire.

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

• Chiamate del bridge GameActions.OpenPopupMenu. La risposta viene salvata separatamente e letta GetContextMenu; Il comando non seleziona la barra dei menu.
• Bridge invia la richiesta sullo streaming del gioco. Si applicano le regole del server; Non è prevista l'attesa di conferma.

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.

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.RequestContextMenu");
UO.RequestContextMenu(UO.GetSerial("lasttarget"));

Parametri e flusso di esecuzione:

• Richiede il menu contestuale dell'oggetto.

var id = UO.GetSerial("lasttarget");
if (Truth(UO.Exists(id)))
{
    UO.RequestContextMenu(id);
}

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

Parametri e flusso di esecuzione:

• Chiamate del bridge GameActions.OpenPopupMenu. La risposta viene salvata separatamente e letta GetContextMenu; Il comando non seleziona la barra dei menu.

return  RunScenario();
 object? RunScenario()
{
    var id = UO.GetSerial("self");
    if (Truth(UO.Exists(id)))
    {
        UO.RequestContextMenu(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;

Parametri e flusso di esecuzione:

• Bridge invia la richiesta sullo streaming del gioco. Si applicano le regole del server; Non è prevista l'attesa di conferma.

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()
    {
        ApplyToLoaded(UO.GetSerial("lasttarget"));
        return null;
    }

    void ApplyToLoaded(dynamic id)
    {
        if (Truth(UO.Exists(id)))
        {
            UO.RequestContextMenu(id);
        }
    }

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

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

Parametri: objID (Any)

Risultato: void / Unit.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.RequestContextMenu: bridge.RequestContextMenu(Arg(0)).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).

Codice interno di implementazione; non è uno script autonomo.

case "requestcontextmenu": bridge.RequestContextMenu(Arg(0)); return InjectionValue.Unit;

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

void UO.SetContextMenuHook(object? menuID, object? entryNumber);

Registra una selezione una tantum di una voce del menu contestuale.

• menuID — Seriale dell'oggetto menu, ridotto a uint; 0 si adatta a qualsiasi serial. Questo non è il server gump ID.
• entryNumber — Indice del punto zero; un valore negativo disabilita l'hook di contesto in sospeso. 0..GetArrayLength(UO.GetContextMenu())-1.

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

• Bridge passa i dati a _manager.SetContextMenuHook, dove è archiviato _contextMenuSerial/_contextMenuEntry. Il gestore ProcessMenuHooks attende un menu contestuale corrispondente esistente.
• Se SelectYokoItem ha esito positivo, i campi vengono cancellati in 0/-1. Il menu non è richiesto da questo setter: utilizzare solo RequestContextMenu. La chiamata in sé non blocca né conferma l'azione del server.

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.

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

Parametri e flusso di esecuzione:

• Registra una selezione una tantum di una voce del menu contestuale.

UO.SetContextMenuHook(0, 0);

Parametri e flusso di esecuzione:

• Bridge passa i dati a _manager.SetContextMenuHook, dove è archiviato _contextMenuSerial/_contextMenuEntry. Il gestore ProcessMenuHooks attende un menu contestuale corrispondente esistente.

return  RunScenario();
 object? RunScenario()
{
    var id = UO.GetSerial("lasttarget");
    UO.SetContextMenuHook(UO.Hex2Int(id), 0);
    UO.RequestContextMenu(id);
    return null;
}

Parametri e flusso di esecuzione:

• Se SelectYokoItem ha esito positivo, i campi vengono cancellati in 0/-1. Il menu non è richiesto da questo setter: utilizzare solo RequestContextMenu. La chiamata in sé non blocca né conferma l'azione del 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()
    {
        UO.SetContextMenuHook(0, -1);
        UO.Print(UO.GetContextMenu());
        return null;
    }
}

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

Parametri: menuID (Any), entryNumber (Any)

Risultato: void / Unit.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.SetContextMenuHook: bridge.SetContextMenuHook(Arg(0), Arg(1)).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).

Codice interno di implementazione; non è uno script autonomo.

case "setcontextmenuhook": bridge.SetContextMenuHook(Arg(0), Arg(1)); return InjectionValue.Unit;

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

void UO.WaitMenu(object? menuCaption, object? elementCaption);
void UO.WaitMenu(object? prompt1, object? choice1, object? prompt2, object? choice2);
void UO.WaitMenu(object? prompt1, object? choice1, object? prompt2, object? choice2, object? prompt3, object? choice3);

Registra fino a tre hook di menu utilizzabili una sola volta.

• menuCaption / prompt1 / prompt2 / prompt3 - Stringa del modello del titolo del menu del server. Le coppie vengono passate nell'ordine intestazione, elemento.
• menuCaption - Stringa del modello del titolo del menu del server. Le coppie vengono passate nell'ordine intestazione, elemento.
• prompt1 - Stringa del modello del titolo del menu del server. Le coppie vengono passate nell'ordine intestazione, elemento.
• prompt2 - Stringa del modello del titolo del menu del server. Le coppie vengono passate nell'ordine intestazione, elemento.
• prompt3 - Stringa del modello del titolo del menu del server. Le coppie vengono passate nell'ordine intestazione, elemento.
• elementCaption / choice1 / choice2 / choice3 — Riga per la selezione di un elemento per l'intestazione corrispondente. Non il normale pulsante gump ID.
• elementCaption — Riga per la selezione di un elemento per l'intestazione corrispondente. Non il normale pulsante gump ID.
• choice1 — Riga per la selezione di un elemento per l'intestazione corrispondente. Non il normale pulsante gump ID.
• choice2 — Riga per la selezione di un elemento per l'intestazione corrispondente. Non il normale pulsante gump ID.
• choice3 — Riga per la selezione di un elemento per l'intestazione corrispondente. Non il normale pulsante gump ID.

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

• Ogni coppia viene passata a _manager.AddMenuHook(prompt, scelta, false). Le forme registrate sono argomenti 2/4/6. false denota un hook occasionale; AutoMenu/due argomenti VendorMenu usa un hook costante.
• Non blocca lo script finché non viene visualizzato il menu. Il gancio viene consumato dal gestore quando il menu è adatto; il risultato dell'esecuzione da parte del server non viene restituito. Per un menu utilizzare WaitingMenu, per i ganci - MenuHookPresent.
• Per i moduli di menu/scelta, il gestore seleziona il primo menu il cui titolo contiene prompt, senza distinzione tra maiuscole e minuscole; SessionMenu seleziona il primo elemento il cui nome contiene una scelta, anch'essa senza distinzione tra maiuscole e minuscole. Il testo vuoto è adatto a chiunque; il testo numerico è un frammento del nome, non un indice. Una selezione riuscita invia una risposta e chiude il menu locale. Un hook singolo viene eliminato solo dopo una selezione riuscita; rimane un gancio permanente.

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.

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.WaitMenu");
UO.WaitMenu("Craft", "Tools");

Parametri e flusso di esecuzione:

• Registra fino a tre hook di menu utilizzabili una sola volta.

UO.WaitMenu("Craft", "Tools");

Parametri e flusso di esecuzione:

• Ogni coppia viene passata a _manager.AddMenuHook(prompt, scelta, false). Le forme registrate sono argomenti 2/4/6. false denota un hook occasionale; AutoMenu/due argomenti VendorMenu usa un hook costante.

return  RunScenario();
 object? RunScenario()
{
    UO.WaitMenu("Craft", "Tools", "Tools", "Shovel");
    return null;
}

Parametri e flusso di esecuzione:

• Non blocca lo script finché non viene visualizzato il menu. Il gancio viene consumato dal gestore quando il menu è adatto; il risultato dell'esecuzione da parte del server non viene restituito. Per un menu utilizzare WaitingMenu, per i ganci - MenuHookPresent.

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.WaitMenu("Craft", "Tools", "Tools", "Shovel", "Amount", "One");
        UO.Print(UO.MenuHookPresent());
        return null;
    }
}

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

Parametri: menuCaption (Any/String), elementCaption (Any/String)

Risultato: void / Unit.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.WaitMenu: bridge.WaitMenu(arguments.Select(value => value.ToString()).ToArray()).
• InjectionScript.Runtime.InjectionValue.ToString: value.ToString().

Codice interno di implementazione; non è uno script autonomo.

case "waitmenu": bridge.WaitMenu(arguments.Select(value => value.ToString()).ToArray()); return InjectionValue.Unit;

Parametri: menuCaption (Any/String), elementCaption (Any/String)

Risultato: void / Unit.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.WaitMenu.

Codice interno di implementazione; non è uno script autonomo.

public void WaitMenu(string prompt, string choice)

            => bridge.WaitMenu(prompt, choice);

Parametri: prompt1 (String), choice1 (String), prompt2 (String), choice2 (String)

Risultato: void / Unit.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.WaitMenu.

Codice interno di implementazione; non è uno script autonomo.

public void WaitMenu(string prompt1, string choice1, string prompt2, string choice2)

            => bridge.WaitMenu(prompt1, choice1, prompt2, choice2);

Parametri: prompt1 (String), choice1 (String), prompt2 (String), choice2 (String), prompt3 (String), choice3 (String)

Risultato: void / Unit.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.WaitMenu.

Codice interno di implementazione; non è uno script autonomo.

public void WaitMenu(string prompt1, string choice1, string prompt2, string choice2, string prompt3, string choice3)

            => bridge.WaitMenu(prompt1, choice1, prompt2, choice2, prompt3, choice3);

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

void UO.WaitTextEntry(object? value);

Cerca di scrivere il testo nella voce di testo del gump corrente.

• value - Testo fino a ToString; salvato come trasmesso.

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

• ExecuteClientApiCompatibility chiama SetGumpValue(-1, "textentry", -1, Text(0)). key=-1 non è un normale indice nullo: la scrittura è possibile solo se un campo esistente è mappato a tale ID nell'implementazione gump.
• Non aspetta un gump futuro, non apre un prompt e non registra un hook. Se non è presente alcun campo corrispondente, SetGumpValue visualizza un messaggio. Per un campo noto, utilizzare SetGump con un ID/index esplicito.

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.

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

Parametri e flusso di esecuzione:

• Cerca di scrivere il testo nella voce di testo del gump corrente.

UO.WaitTextEntry("Example");

Parametri e flusso di esecuzione:

• ExecuteClientApiCompatibility chiama SetGumpValue(-1, "textentry", -1, Text(0)). key=-1 non è un normale indice nullo: la scrittura è possibile solo se un campo esistente è mappato a tale ID nell'implementazione gump.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.GetGumpsCount() > 0))
    {
        UO.WaitTextEntry("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;

Parametri e flusso di esecuzione:

• Non aspetta un gump futuro, non apre un prompt e non registra un hook. Se non è presente alcun campo corrispondente, SetGumpValue visualizza un messaggio. Per un campo noto, utilizzare SetGump con un ID/index esplicito.

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.WaitTextEntry("Example");
        UO.Print("Check the target field in the current gump");
        return null;
    }
}