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

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

Ispezione di oggetti, piastrelle e gump, controllo di nomi, parametri e firme API. La presenza di una firma non conferma la possibilità di un'azione di gioco nello stato attuale.

UO.Help · UO.Dump · UO.Info · UO.InfoColor · UO.GetInfo · UO.ExtendedInfo · UO.InfoTile · UO.InfoGump · UO.InfoGumps · UO.ApiNameExists · UO.ApiParameterExists · UO.ApiSignatureExists · UO.Version · UO.ClientInfo

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

UO.InfoGump();

Parametri, risultato e tutti gli scenari

return UO.ApiNameExists("UO.GetType");

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

int UO.ApiNameExists(object? name);

Controlla la registrazione del nome della funzione nativa richiamata.

• name - Obbligatorio string: Il nome esatto registrato, non l'espressione chiamante. Gli spazi tra maiuscole e bordi non sono importanti; UO. non viene aggiunto automaticamente. Un nome vuoto o sconosciuto dà 0. Le procedure utente non vengono prese in considerazione.

int: 1 indica che il nome è registrato, 0 che non lo è. In C# usa result != 0 o result == 0. Confrontare int con true o false non è valido. La registrazione non conferma un’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 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.ApiNameExists("UO.GetType");
UO.Print("ApiNameExists: " + Convert.ToString(result));

Parametri e flusso di esecuzione:

• Il primo esempio testa il nome del gioco con un UO esplicito. e restituisce 1. Il nome esatto da testare e il numero di argomenti quando è richiesto sono visibili nella chiamata.

return UO.ApiNameExists("UO.GetType");

Si verifica solo la registrazione dei nomi nativi. Convert.ToInt32 è un metodo .NET, non una voce dell’API UO, quindi ApiNameExists restituisce 0. Il metodo resta disponibile nel normale C#.

return  RunScenario();
 object? RunScenario()
{
    var name = "Convert.ToInt32";
    return UO.ApiNameExists(name);
    return null;
}

Ogni risultato numerico viene confrontato con 0; poi && combina due valori bool. Per questi nomi il risultato è false.

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()
    {
        return HasBoth("GetType", "UO.GetType");
        return null;
    }

    dynamic HasBoth(dynamic first, dynamic second)
    {
        return UO.ApiNameExists(first) != 0 && UO.ApiNameExists(second) != 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: name (String)

Risultato: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ApiNameExists.
• InjectionScript.Runtime.InjectionApiUO.NormalizeApiName: NormalizeApiName(name).

Codice interno di implementazione; non è uno script autonomo.

public int ApiNameExists(string name)

        {

            string normalized = NormalizeApiName(name);

            return metadata.NativeSubrutines.Any(definition =>

                definition.Name.Equals(normalized, StringComparison.OrdinalIgnoreCase)) ? 1 : 0;

        }

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

int UO.ApiParameterExists(object? name);

Controlla se è registrato un valore di runtime o un oggetto denominato.

• name - Obbligatorio string: Il nome esatto registrato, non l'espressione chiamante. Gli spazi tra maiuscole e bordi non sono importanti; UO. non viene aggiunto automaticamente. Un nome vuoto o sconosciuto dà 0. Le procedure utente non vengono prese in considerazione.

int: 1 indica che il nome è registrato, 0 che non lo è. In C# usa result != 0 o result == 0. Confrontare int con true o false non è valido. La registrazione non conferma un’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 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.ApiParameterExists("backpack");
UO.Print("ApiParameterExists: " + Convert.ToString(result));

Parametri e flusso di esecuzione:

• Il primo esempio testa il nome del gioco con un UO esplicito. e restituisce 1. Il nome esatto da testare e il numero di argomenti quando è richiesto sono visibili nella chiamata.

return UO.ApiParameterExists("UO.GetHP");

Viene verificato il selettore registrato backpack, che restituisce 1. Non vengono verificati i parametri dei metodi C# né l’esistenza di uno zaino nel mondo di gioco.

return  RunScenario();
 object? RunScenario()
{
    var name = "backpack";
    return UO.ApiParameterExists(name);
    return null;
}

Parametri e flusso di esecuzione:

• Il terzo esempio contiene una funzione di supporto completa. Confronta la forma breve rimossa o l'arità non supportata con la forma disponibile. I parametri nome, primo, secondo e conteggio passano i nomi/conteggi invariati. Il risultato è 0 per i controlli di chiamata e 0:1 per i controlli di valore.

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()
    {
        return CompareNames("GetHP", "UO.GetHP");
        return null;
    }

    dynamic CompareNames(dynamic first, dynamic second)
    {
        return Convert.ToString(UO.ApiParameterExists(first)) + ":" + Convert.ToString(UO.ApiParameterExists(second));
    }
}

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: name (String)

Risultato: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ApiParameterExists.
• InjectionScript.Runtime.Metadata.IntrinsicVariableExists: metadata.IntrinsicVariableExists(value).

Codice interno di implementazione; non è uno script autonomo.

public int ApiParameterExists(string name)

        {

            string value = (name ?? string.Empty).Trim();

            if (value.Length == 0)

                return 0;



            if (Metadata.ShortcutVariables.Any(item => item.Equals(value, StringComparison.OrdinalIgnoreCase)))

                return 1;



            return metadata.IntrinsicVariableExists(value) ? 1 : 0;

        }

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

int UO.ApiSignatureExists(object? name, object? argumentCount);

Verifica la registrazione di un nome con il numero di argomenti specificato.

• name - Obbligatorio string: Il nome esatto registrato, non l'espressione chiamante. Gli spazi tra maiuscole e bordi non sono importanti; UO. non viene aggiunto automaticamente. Un nome vuoto o sconosciuto dà 0. Le procedure utente non vengono prese in considerazione.
• argumentCount — Obbligatorio int: il numero completo di argomenti posizionali, inclusi quelli opzionali passati esplicitamente. Una quantità negativa o non supportata dà 0. I tipi degli argomenti stessi non vengono controllati.

int: 1 indica che il nome è registrato, 0 che non lo è. In C# usa result != 0 o result == 0. Confrontare int con true o false non è valido. La registrazione non conferma un’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 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.ApiSignatureExists("UO.GetType", 1);
UO.Print("ApiSignatureExists: " + Convert.ToString(result));

Parametri e flusso di esecuzione:

• Il primo esempio testa il nome del gioco con un UO esplicito. e restituisce 1. Il nome esatto da testare e il numero di argomenti quando è richiesto sono visibili nella chiamata.

return UO.ApiSignatureExists("UO.GetType",1);

Vengono verificate le forme di UO.FindType con uno e zero argomenti. Il risultato è la stringa "1:0"; la forma senza argomenti non è registrata.

return  RunScenario();
 object? RunScenario()
{
    return Convert.ToString(UO.ApiSignatureExists("UO.FindType", 1)) + ":" + Convert.ToString(UO.ApiSignatureExists("UO.FindType", 0));
    return null;
}

Parametri e flusso di esecuzione:

• Il terzo esempio contiene una funzione di supporto completa. Confronta la forma breve rimossa o l'arità non supportata con la forma disponibile. I parametri nome, primo, secondo e conteggio passano i nomi/conteggi invariati. Il risultato è 0 per i controlli di chiamata e 0:1 per i controlli di valore.

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()
    {
        return CheckForm("UO.GetType", 0);
        return null;
    }

    dynamic CheckForm(dynamic name, dynamic count)
    {
        return UO.ApiSignatureExists(name, count);
    }
}

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: name (String), argumentCount (Integer)

Risultato: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ApiSignatureExists.
• InjectionScript.Runtime.Metadata.NativeSubrutineExists: metadata.NativeSubrutineExists(NormalizeApiName(name), argumentCount).
• InjectionScript.Runtime.InjectionApiUO.NormalizeApiName: NormalizeApiName(name).

Codice interno di implementazione; non è uno script autonomo.

public int ApiSignatureExists(string name, int argumentCount)

            => metadata.NativeSubrutineExists(NormalizeApiName(name), argumentCount) ? 1 : 0;

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

dynamic UO.ClientInfo();

Legge brevi informazioni sul client in esecuzione.

Non ci sono parametri.

Matrice di tre string: [0] - nome del prodotto, [1] - versione del client in esecuzione, [2] - directory del client. Gli indici iniziano con 0. Questa non è la stringa JSON, né è un dizionario.

• I dati vengono letti da RuntimeProductName, RuntimeProductVersion e ClientPath. Il comando non cambia nulla e non invia nulla al server.
• Utilizzare ArrayLength prima dell'indicizzazione in una funzione di supporto generale. Non confondere le informazioni sul client con le statistiche dei personaggi o la versione del server.
• Legge le informazioni sull'attuale client ClassicUO.

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

Parametri e flusso di esecuzione:

• 0 - prodotto, 1 - versione, 2 - catalogo. Il valore della versione viene preso all'avvio; nell'esempio non è risolto.

var info = UO.ClientInfo();
UO.Print("Product: " + info[0]);
UO.Print("Client version: " + info[1]);
UO.Print("Client folder: " + info[2]);

Parametri e flusso di esecuzione:

• ArrayLength restituisce il numero di campi. L'ultimo indice valido è uguale alla lunghezza meno 1.

return  RunScenario();
 object? RunScenario()
{
    var info = UO.ClientInfo();
    var i = 0;
    while (Truth(i < ArrayLength(info)))
    {
        UO.Print(Convert.ToString(i) + ": " + info[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;

Parametri e flusso di esecuzione:

• ClientCaption restituisce una stringa di titolo e versione. L'array originale non viene modificato.

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.Print(ClientCaption());
        return null;
    }

    dynamic ClientCaption()
    {
        var info = UO.ClientInfo();
        if (Truth(ArrayLength(info) < 2))
        {
            return "Client information unavailable";
        }

        return info[0] + " / " + info[1];
    }

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

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 / Array.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.RuntimeProductName: bridge.RuntimeProductName.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.RuntimeProductVersion: bridge.RuntimeProductVersion.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.ClientPath: bridge.ClientPath.

Codice interno di implementazione; non è uno script autonomo.

case "clientinfo":

                    return new InjectionValue(new[]

                    {

                        new InjectionValue(bridge.RuntimeProductName),

                        new InjectionValue(bridge.RuntimeProductVersion),

                        new InjectionValue(bridge.ClientPath)

                    });

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

void UO.Dump();
void UO.Dump(object? @object);

Stampa un'istantanea diagnostica di un oggetto noto al client.

• object - Opzionale serial/link. Senza argomenti, viene utilizzato bridge.LastTarget.

void: nessun valore restituito.

• Il messaggio contiene serial come 0xXXXXXXX, nome, graphic/type, hue e X/Y/Z. I campi vengono letti dal modello locale; un oggetto mancante fornisce un nome vuoto e campi nulli. Il comando non richiede le proprietà del server più recenti.

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

Parametri e flusso di esecuzione:

• Un argomento mancante significa LastTarget.

UO.Dump();

Parametri e flusso di esecuzione:

• Tutti i campi sono specifici per il tuo personaggio.

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

Parametri e flusso di esecuzione:

• Il test Exists separa un modello mancante da un oggetto con zero campi.

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.LastTarget();
        if (Truth(UO.Exists(id)))
        {
            UO.Dump(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;
}

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.
• InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Arg: Arg(0, bridge.LastTarget).
• InjectionScript.Runtime.InjectionApiUO.SystemMessage: SystemMessage($"0x{id:X8} {bridge.GetName(id)} type=0x{bridge.GetGraphics(id):X4} hue=0x{bridge.GetColor(id):X4} xyz={bridge.GetX(id)},{bridge.GetY(id)},{bridge.GetZ(id)}").
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetName: bridge.GetName(id).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetGraphics: bridge.GetGraphics(id).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetColor: bridge.GetColor(id).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetX: bridge.GetX(id).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetY: bridge.GetY(id).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetZ: bridge.GetZ(id).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.LastTarget: bridge.LastTarget.

Codice interno di implementazione; non è uno script autonomo.

case "dump":

                {

                    int id = Arg(0, bridge.LastTarget);

                    SystemMessage($"0x{id:X8} {bridge.GetName(id)} type=0x{bridge.GetGraphics(id):X4} hue=0x{bridge.GetColor(id):X4} xyz={bridge.GetX(id)},{bridge.GetY(id)},{bridge.GetZ(id)}");

                    break;

                }

Parametri: object (Any)

Risultato: void / Unit.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
• InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Arg: Arg(0, bridge.LastTarget).
• InjectionScript.Runtime.InjectionApiUO.SystemMessage: SystemMessage($"0x{id:X8} {bridge.GetName(id)} type=0x{bridge.GetGraphics(id):X4} hue=0x{bridge.GetColor(id):X4} xyz={bridge.GetX(id)},{bridge.GetY(id)},{bridge.GetZ(id)}").
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetName: bridge.GetName(id).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetGraphics: bridge.GetGraphics(id).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetColor: bridge.GetColor(id).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetX: bridge.GetX(id).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetY: bridge.GetY(id).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetZ: bridge.GetZ(id).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.LastTarget: bridge.LastTarget.

Codice interno di implementazione; non è uno script autonomo.

case "dump":

                {

                    int id = Arg(0, bridge.LastTarget);

                    SystemMessage($"0x{id:X8} {bridge.GetName(id)} type=0x{bridge.GetGraphics(id):X4} hue=0x{bridge.GetColor(id):X4} xyz={bridge.GetX(id)},{bridge.GetY(id)},{bridge.GetZ(id)}");

                    break;

                }

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

dynamic UO.ExtendedInfo();

Restituisce quattro campi della configurazione della connessione client corrente.

Non ci sono parametri.

Array [ClientPath:string, CurrentProfilePath:string, GameServerAddress:string, GameServerPort:int].

• L'ordine dei campi è fisso. ClientPath e CurrentProfilePath sono percorsi client. GameServerAddress e GameServerPort leggono le impostazioni globali. GlobalSettings.IP/Porta: questo è l'indirizzo configurato, senza controllare l'effettiva sessione del peer manager. L'elenco non contiene una password e non richiede informazioni al server. Sono possibili valori vuoti prima di selezionare un profilo/connessione.

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

Parametri e flusso di esecuzione:

• L'array contiene tipi misti, quindi viene utilizzato Convert.ToString.

var info = UO.ExtendedInfo();
for (int i = (int)(0); i <= ArrayLength(info)-1; i += (int)(1))
{
    UO.Print(Convert.ToString(info[i]));
}

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

Parametri e flusso di esecuzione:

• Gli indici 2 e 3 sono l'indirizzo e la porta.

return  RunScenario();
 object? RunScenario()
{
    var info = UO.ExtendedInfo();
    UO.Print(Convert.ToString(info[2]) + ":" + Convert.ToString(info[3]));
    return null;
}

Parametri e flusso di esecuzione:

• Indice 1 — CurrentProfilePath, non ClientPath.

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.ExtendedInfo();
        var path = info[1];
        UO.Print(path);
        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.ClientPath: bridge.ClientPath.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CurrentProfilePath: bridge.CurrentProfilePath.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GameServerAddress: bridge.GameServerAddress.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GameServerPort: bridge.GameServerPort.

Codice interno di implementazione; non è uno script autonomo.

case "extendedinfo":

                    return new InjectionValue(new[] { new InjectionValue(bridge.ClientPath), new InjectionValue(bridge.CurrentProfilePath), new InjectionValue(bridge.GameServerAddress), new InjectionValue(bridge.GameServerPort) });

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

string UO.GetInfo(object? arg);

Restituisce il nome del carattere solo per il selettore di caratteri esatto.

• arg - string. Il valore esatto del carattere con distinzione tra maiuscole e minuscole chiama GetName("self"); qualsiasi altro valore non è riconosciuto.

string — nome del tuo personaggio per personaggio; stringa letterale UNKNOWN per tutti gli altri argomenti. Se non è presente alcun carattere, il nome potrebbe essere vuoto.

• Il confronto StringComparison.Ordinal fa distinzione tra maiuscole e minuscole. È supportato solo il selettore di caratteri. Il comando non effettua richieste di rete: legge il nome dal modello di carattere locale. La finestra FillInfoWindow è controllata separatamente.

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.

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

Parametri e flusso di esecuzione:

• Il carattere esatto letterale legge self.

var name = UO.GetInfo("character");
UO.Print(name);

Parametri e flusso di esecuzione:

• Il carattere non corrisponde e restituisce UNKNOWN.

return  RunScenario();
 object? RunScenario()
{
    var value = UO.GetInfo("Character");
    UO.Print(value);
    return null;
}

Parametri e flusso di esecuzione:

• Il profilo non è supportato da questa implementazione.

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 value = UO.GetInfo("profile");
        UO.Print(value);
        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: arg (String)

Risultato: string / String.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.GetInfo.
• InjectionScript.Runtime.InjectionApiUO.GetName: GetName("self").

Codice interno di implementazione; non è uno script autonomo.

private string GetInfo(string arg)

        {

            if (arg.Equals("character", StringComparison.Ordinal))

                return GetName("self");



            return "UNKNOWN";

        }

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

void UO.Help();

Non ci sono parametri.

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

• Modifica o visualizza solo i dati locali specificati. Questo comando non ha la conferma 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.Help");
UO.Help();

Parametri e flusso di esecuzione:

• Mostra il suggerimento locale su C# IDE.

UO.Help();

Parametri e flusso di esecuzione:

• ExecuteLegacyManualAlias visualizza una riga su UO.*, il prefisso chat configurato e Opzioni > C# IDE > Manuale tramite SystemMessage. Una richiesta di aiuto non viene inviata al server.

return  RunScenario();
 object? RunScenario()
{
    UO.Help();
    UO.OpenIDE();
    return null;
}

Parametri e flusso di esecuzione:

• Modifica o visualizza solo i dati locali specificati. Questo comando non ha la conferma 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.Help();
        UO.Print("Options > C# IDE > Manual");
        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.
• InjectionScript.Runtime.InjectionApiUO.SystemMessage: SystemMessage("C# Scripts IDE: use UO.* in scripts or the configured chat prefix. Open Options > C# Scripts IDE > Manual.").

Codice interno di implementazione; non è uno script autonomo.

case "help": SystemMessage("C# Scripts IDE: use UO.* in scripts or the configured chat prefix. Open Options > C# Scripts IDE > Manual."); break;

string UO.Info();
string UO.Info(object? serial);
string UO.Info(object? type, object? x, object? y);
string UO.Info(object? type, object? x, object? y, object? z);

Il contesto determina la visualizzazione: i comandi della chat grafica aprono una tabella con campi, valori, Ctrl+C e scorrimento. Gli script C# ricevono testo senza finestre o mirino, anche con il gioco aperto. Sono disponibili solo i dati noti al client.

Info e InfoTile senza argomenti attivano il mirino nella chat grafica. In uno script Info() legge l’ultimo oggetto bersaglio o il giocatore; InfoTile() il terreno sotto il giocatore. serial, type e coordinate selezionano un elemento preciso. Il terzo argomento di InfoTile(x,y,map) è la mappa.

• serial — Seriale oggetto o alias salvato.
• type — ID grafico; -1 accetta qualsiasi tipo nella posizione.
• x — Coordinata X del mondo.
• y — Coordinata Y del mondo.
• z — Altezza Z; la forma breve usa 0.

Configurare il prefisso in C# Scripts IDE; # è un esempio. Separare i parametri con spazi e racchiudere il testo fra virgolette. id significa serial, type significa graphic. xy x y [z] seleziona il primo oggetto caricato nel punto; type da solo il primo risultato. Il terzo argomento di InfoTile(x,y,map) è la mappa, non Z.

#info
#UO.Info id 0x40001234
#info type 0x0EED
#info xy 1450 1690
#info type 0x0EED xy 1450 1690 0

Ogni blocco è un .csx completo. Sostituire serial, tipi e coordinate di esempio. Ordine e argomenti C# nominati seguono la firma.

string report = UO.Info(0x40001234);
UO.Print(report);

string InspectSelf() => UO.Info("self");
UO.Print(InspectSelf());

foreach (int serial in new[] { 0x40001234, 0x40005678 })
{
    string report = UO.Info(serial);
    UO.Print(report);
}

new CommandSample().Execute(UO);

sealed class CommandSample
{
    public void Execute(global::ClassicUO.CSharp.CSharpGameApi api)
    {
        string report = api.Info(0x40001234);
        api.Print(report);
    }
}

CSharpGameApi.Info
  -> CSharpScriptGlobals
  -> InjectionScript.Runtime.InjectionApiUO.Info

ClassicUOInjectionApiBridge -> YokoInfoReport -> YokoInfoGump

string UO.InfoColor();
string UO.InfoColor(object? serial);

Il contesto determina la visualizzazione: i comandi della chat grafica aprono una tabella con campi, valori, Ctrl+C e scorrimento. Gli script C# ricevono testo senza finestre o mirino, anche con il gioco aperto. Sono disponibili solo i dati noti al client.

Info e InfoTile senza argomenti attivano il mirino nella chat grafica. In uno script Info() legge l’ultimo oggetto bersaglio o il giocatore; InfoTile() il terreno sotto il giocatore. serial, type e coordinate selezionano un elemento preciso. Il terzo argomento di InfoTile(x,y,map) è la mappa.

• serial — Seriale oggetto o alias salvato.

Configurare il prefisso in C# Scripts IDE; # è un esempio. Separare i parametri con spazi e racchiudere il testo fra virgolette. id significa serial, type significa graphic. xy x y [z] seleziona il primo oggetto caricato nel punto; type da solo il primo risultato. Il terzo argomento di InfoTile(x,y,map) è la mappa, non Z.

#infocolor 0x40001234

Ogni blocco è un .csx completo. Sostituire serial, tipi e coordinate di esempio. Ordine e argomenti C# nominati seguono la firma.

UO.Print(UO.InfoColor(0x40001234));

string report = UO.InfoColor();
UO.Print(report);

foreach (int serial in new[] { 0x40001234, 0x40005678 })
    UO.Print(UO.InfoColor(serial));

new CommandSample().Execute(UO);

sealed class CommandSample
{
    public void Execute(global::ClassicUO.CSharp.CSharpGameApi api)
    {
        api.Print(api.InfoColor(0x40001234));
    }
}

CSharpGameApi.InfoColor
  -> CSharpScriptGlobals
  -> InjectionScript.Runtime.InjectionApiUO.InfoColor

ClassicUOInjectionApiBridge -> YokoInfoReport -> YokoInfoGump

string UO.InfoGump();
string UO.InfoGump(object? gump);

Il contesto determina la visualizzazione: i comandi della chat grafica aprono una tabella con campi, valori, Ctrl+C e scorrimento. Gli script C# ricevono testo senza finestre o mirino, anche con il gioco aperto. Sono disponibili solo i dati noti al client.

InfoGump() legge l’ultima finestra attiva del server o del client. ID o indice seleziona una finestra; last, LastGump e Last Gump indicano l’ultima. InfoGumps restituisce l’elenco senza gli ispettori. Solo i comandi grafici aprono la tabella.

• gump — ID o indice finestra server; -1 seleziona l’ultima attiva.

Configurare il prefisso in C# Scripts IDE; # è un esempio. Separare i parametri con spazi e racchiudere il testo fra virgolette. id significa serial, type significa graphic. xy x y [z] seleziona il primo oggetto caricato nel punto; type da solo il primo risultato. Il terzo argomento di InfoTile(x,y,map) è la mappa, non Z.

#infogump
#infogump last
#info gump last gump
#infogump 0x12345678

Ogni blocco è un .csx completo. Sostituire serial, tipi e coordinate di esempio. Ordine e argomenti C# nominati seguono la firma.

string report = UO.InfoGump();
UO.Print(report);

UO.Print(UO.InfoGump(0x12345678));

string ReadLatestWindow() => UO.InfoGump();
UO.Print(ReadLatestWindow());

new CommandSample().Execute(UO);

sealed class CommandSample
{
    public void Execute(global::ClassicUO.CSharp.CSharpGameApi api)
    {
        string report = api.InfoGump();
        api.Print(report);
    }
}

CSharpGameApi.InfoGump
  -> CSharpScriptGlobals
  -> InjectionScript.Runtime.InjectionApiUO.InfoGump

ClassicUOInjectionApiBridge -> YokoInfoReport -> YokoInfoGump

string UO.InfoGumps();
string UO.InfoGumps(object? gump);

Il contesto determina la visualizzazione: i comandi della chat grafica aprono una tabella con campi, valori, Ctrl+C e scorrimento. Gli script C# ricevono testo senza finestre o mirino, anche con il gioco aperto. Sono disponibili solo i dati noti al client.

InfoGump() legge l’ultima finestra attiva del server o del client. ID o indice seleziona una finestra; last, LastGump e Last Gump indicano l’ultima. InfoGumps restituisce l’elenco senza gli ispettori. Solo i comandi grafici aprono la tabella.

• gump — ID o indice finestra server; -1 seleziona l’ultima attiva.

Configurare il prefisso in C# Scripts IDE; # è un esempio. Separare i parametri con spazi e racchiudere il testo fra virgolette. id significa serial, type significa graphic. xy x y [z] seleziona il primo oggetto caricato nel punto; type da solo il primo risultato. Il terzo argomento di InfoTile(x,y,map) è la mappa, non Z.

#infogumps

Ogni blocco è un .csx completo. Sostituire serial, tipi e coordinate di esempio. Ordine e argomenti C# nominati seguono la firma.

UO.Print(UO.InfoGumps());

string report = UO.InfoGumps(0x12345678);
UO.Print(report);

string ReadAllWindows() => UO.InfoGumps();
UO.Print(ReadAllWindows());

new CommandSample().Execute(UO);

sealed class CommandSample
{
    public void Execute(global::ClassicUO.CSharp.CSharpGameApi api)
    {
        api.Print(api.InfoGumps());
    }
}

CSharpGameApi.InfoGumps
  -> CSharpScriptGlobals
  -> InjectionScript.Runtime.InjectionApiUO.InfoGumps

ClassicUOInjectionApiBridge -> YokoInfoReport -> YokoInfoGump

string UO.InfoTile();
string UO.InfoTile(object? x);
string UO.InfoTile(object? x, object? y);
string UO.InfoTile(object? x, object? y, object? map);
string UO.InfoTile(object? type, object? x, object? y, object? z);
string UO.InfoTile(object? type, object? x, object? y, object? z, object? map);

Il contesto determina la visualizzazione: i comandi della chat grafica aprono una tabella con campi, valori, Ctrl+C e scorrimento. Gli script C# ricevono testo senza finestre o mirino, anche con il gioco aperto. Sono disponibili solo i dati noti al client.

Info e InfoTile senza argomenti attivano il mirino nella chat grafica. In uno script Info() legge l’ultimo oggetto bersaglio o il giocatore; InfoTile() il terreno sotto il giocatore. serial, type e coordinate selezionano un elemento preciso. Il terzo argomento di InfoTile(x,y,map) è la mappa.

• map — Numero mappa; se omesso usa quella attuale.
• type — ID grafico; -1 accetta qualsiasi tipo nella posizione.
• x — Coordinata X del mondo.
• y — Coordinata Y del mondo.
• z — Altezza Z; la forma breve usa 0.

Configurare il prefisso in C# Scripts IDE; # è un esempio. Separare i parametri con spazi e racchiudere il testo fra virgolette. id significa serial, type significa graphic. xy x y [z] seleziona il primo oggetto caricato nel punto; type da solo il primo risultato. Il terzo argomento di InfoTile(x,y,map) è la mappa, non Z.

#infotile
#info tile xy 1450 1690
#infotile 1450 1690 0
#infotile type 0x0EED 1450 1690 0 0

Ogni blocco è un .csx completo. Sostituire serial, tipi e coordinate di esempio. Ordine e argomenti C# nominati seguono la firma.

UO.Print(UO.InfoTile(1450, 1690));

string report = UO.InfoTile(1450, 1690, 0);
UO.Print(report);

UO.Print(UO.InfoTile(0x0EED, 1450, 1690, 0, 0));

new CommandSample().Execute(UO);

sealed class CommandSample
{
    public void Execute(global::ClassicUO.CSharp.CSharpGameApi api)
    {
        api.Print(api.InfoTile(1450, 1690));
    }
}

CSharpGameApi.InfoTile
  -> CSharpScriptGlobals
  -> InjectionScript.Runtime.InjectionApiUO.InfoTile

ClassicUOInjectionApiBridge -> YokoInfoReport -> YokoInfoGump

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

void UO.Version();

Stampa il nome e la versione runtime del prodotto.

Non ci sono parametri.

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

• ExecuteLegacyManualAlias uscite bridge.RuntimeProductName e bridge.RuntimeProductVersion tramite SystemMessage. Questa è una stringa di registro, non il numero di versione restituito.
• Modifica o visualizza solo i dati locali specificati. Questo comando non ha la conferma 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.Version");
UO.Version();

Parametri e flusso di esecuzione:

• Stampa il nome e la versione runtime del prodotto.

UO.Version();

Parametri e flusso di esecuzione:

• ExecuteLegacyManualAlias uscite bridge.RuntimeProductName e bridge.RuntimeProductVersion tramite SystemMessage. Questa è una stringa di registro, non il numero di versione restituito.

return  RunScenario();
 object? RunScenario()
{
    UO.Version();
    UO.Help();
    return null;
}

Parametri e flusso di esecuzione:

• Modifica o visualizza solo i dati locali specificati. Questo comando non ha la conferma 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.Version();
        UO.Print(UO.GetUserCodepage());
        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.
• InjectionScript.Runtime.InjectionApiUO.SystemMessage: SystemMessage($"{bridge.RuntimeProductName} v{bridge.RuntimeProductVersion}").
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.RuntimeProductName: bridge.RuntimeProductName.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.RuntimeProductVersion: bridge.RuntimeProductVersion.

Codice interno di implementazione; non è uno script autonomo.

case "version": SystemMessage($"{bridge.RuntimeProductName} v{bridge.RuntimeProductVersion}"); break;