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

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

1 · 2 · 3 · 4 · 5

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

int UO.GetSex();

Legge il sesso e il codice razziale dal modello client.

Non ci sono parametri.

int - codice compatibile: 0=maschio umano, 1=femmina umana, 2=maschio elfo, 3=femmina elfo, 4=maschio gargoyle, 5=femmina gargoyle. Anche senza carattere è 0, quindi controlla la disponibilità di Exists(self). Questa non è una semplice femmina bool.

• I dati locali già ricevuti vengono letti. La richiesta non apre lo stato e non forza il server a inviare un aggiornamento. Dopo la morte, la transizione della mappa o l'eliminazione di un oggetto, i valori possono cambiare tra due chiamate.
• C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

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.GetSex();
UO.Print("GetSex: " + Convert.ToString(result));

Parametri e flusso di esecuzione:

• La chiamata senza argomenti si riferisce a self. Il sesso e il codice razziale vengono memorizzati nel valore.
• Convert.ToString converte il numero da emettere e non cambia il significato del risultato.

var value = UO.GetSex();
UO.Print("GetSex: " + Convert.ToString(value));

Parametri e flusso di esecuzione:

• Il valore viene letto una volta senza argomenti. Il sesso e il codice razza vengono utilizzati nel calcolo o nella condizione mostrata.
• Le soglie numeriche sono esempi di condizioni di script e non di nuovi limiti client. Il campo memorizza le unità server e le restrizioni sopra descritte.

return  RunScenario();
 object? RunScenario()
{
    var value = UO.GetSex();
    if (Truth(value == 4) || Truth(value == 5))
    {
        UO.Print("Gargoyle sex/race code");
    }

    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:

• Entrambe le chiamate senza argomento leggono il loro valore corrente. UO.Wait(1000) dà una pausa in millisecondi tra gli scatti.
• Il cambiamento viene confrontato: genere e codice razziale. Un esempio non cambia nulla al mondo e non aspetta all'infinito. Gli eventi entro questo secondo potrebbero essere persi.

return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

    async public Task<object?> RunScenarioAsync()
    {
        var before = UO.GetSex();
        await Delay(1000);
        var after = UO.GetSex();
        if (Truth(before != after))
        {
            UO.Print("Before: " + Convert.ToString(before) + "; after: " + Convert.ToString(after));
        }

        return null;
    }

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

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: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [GetSex].
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Sex: bridge.Sex.

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

Codice interno di implementazione; non è uno script autonomo.

() => bridge.Sex

Creazione API: Queste funzioni registrano l’API. Non vengono eseguite di nuovo a ogni chiamata del comando.

• InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddInteger.

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

int UO.GetStam();
dynamic UO.GetStam(object? objID);

Legge la resistenza attuale dal modello locale.

• objID — Oggetto opzionale nei moduli visualizzati: serial per numero/stringa esadecimale, self, lasttarget o nome registrato AddObject. Questo non è type. Senza discutere, leggi self. Il testo sconosciuto in alcuni moduli causa un errore di conversione; controlla il nome prima di chiamare.

int è il valore del campo Stamina, non una percentuale o bool. 0 può essere un valore reale o un'indicazione di dati mancanti. Il massimo zero non può essere utilizzato come divisore. Per mobile di qualcun altro i significati potrebbero essere sconosciuti. HP/HitsMax può contenere la scala relativa del server anziché i punti esatti. HP=0 non prova la morte; c'è Dead/IsDead per questo.

• Il comando non apre lo stato e non richiede un aggiornamento del server. Il client legge solo i dati già caricati. Non cambia caratteristiche e non invia pacchetti.
• Il risultato è una lettura separata. Il mondo può cambiare tra Exists e la prossima sfida; più query non formano uno snapshot atomico.
• Durante la lettura di un oggetto, World.Get rifiuta l'o mancante o IsDestroyed e risulta in 0. HP/HitsMax vengono letti dall'Entità, inclusi gli elementi con questi campi; Mana/Stamina - solo per dispositivi mobili. Senza discutere, leggi self. La variante con lo stesso nome senza parametri non ha necessariamente una variante con ID: vedi firme.
• La lettura senza argomenti restituisce anche 0 per un giocatore scomparso o distrutto. Questo vale anche per Mana/Stamina diretti e i loro massimi, non solo per le forme World.Get. Un personaggio morto presente può conservare valori.

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.GetStam();
UO.Print("GetStam: " + Convert.ToString(result));

Parametri e flusso di esecuzione:

• La chiamata senza argomenti legge self. value memorizza un numero, Convert.ToString lo converte solo per il messaggio.

var value = UO.GetStam();
UO.Print("GetStam: " + Convert.ToString(value));

Parametri e flusso di esecuzione:

• Viene visualizzata la soglia o il calcolo applicato per questo campo. I numeri nella condizione sono impostazioni di esempio, non limiti del server. Prima di dividere per il massimo se ne controlla la positività.

return  RunScenario();
 object? RunScenario()
{
    var value = UO.GetStam();
    if (Truth(value < 15))
    {
        UO.Print("Known stamina is below the movement threshold of 15");
    }

    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:

• lasttarget — oggetto precedentemente selezionato; Exists verifica la disponibilità. obj è l'unico parametro di ReadValue. La funzione restituisce il numero del comando invariato e viene fornito nella sua interezza.

return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        if (Truth(UO.Exists("lasttarget")))
        {
            var value = ReadValue("lasttarget");
            UO.Print("Selected value: " + Convert.ToString(value));
        }

        return null;
    }

    dynamic ReadValue(dynamic obj)
    {
        return UO.GetStam(obj);
    }

    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: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [GetStam].
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Stamina: bridge.Stamina.

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

Codice interno di implementazione; non è uno script autonomo.

() => bridge.Stamina

Creazione API: Queste funzioni registrano l’API. Non vengono eseguite di nuovo a ogni chiamata del comando.

• InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddInteger.

Parametri: objID (Any)

Risultato: dynamic / Any.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "getstam": return new InjectionValue(arguments.Length > 0 ? bridge.GetStamina(Arg(0)) : bridge.Stamina);

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

int UO.GetStamina();

Legge la resistenza attuale dal modello locale.

Non ci sono parametri.

int è il valore del campo Stamina, non una percentuale o bool. 0 può essere un valore reale o un'indicazione di dati mancanti. Il massimo zero non può essere utilizzato come divisore. Per mobile di qualcun altro i significati potrebbero essere sconosciuti. HP/HitsMax può contenere la scala relativa del server anziché i punti esatti. HP=0 non prova la morte; c'è Dead/IsDead per questo.

• Il comando non apre lo stato e non richiede un aggiornamento del server. Il client legge solo i dati già caricati. Non cambia caratteristiche e non invia pacchetti.
• Il risultato è una lettura separata. Il mondo può cambiare tra Exists e la prossima sfida; più query non formano uno snapshot atomico.
• Durante la lettura di un oggetto, World.Get rifiuta l'o mancante o IsDestroyed e risulta in 0. HP/HitsMax vengono letti dall'Entità, inclusi gli elementi con questi campi; Mana/Stamina - solo per dispositivi mobili. Senza discutere, leggi self. La variante con lo stesso nome senza parametri non ha necessariamente una variante con ID: vedi firme.
• La lettura senza argomenti restituisce anche 0 per un giocatore scomparso o distrutto. Questo vale anche per Mana/Stamina diretti e i loro massimi, non solo per le forme World.Get. Un personaggio morto presente può conservare valori.

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.GetStamina();
UO.Print("GetStamina: " + Convert.ToString(result));

Parametri e flusso di esecuzione:

• La chiamata senza argomenti legge self. value memorizza un numero, Convert.ToString lo converte solo per il messaggio.

var value = UO.GetStamina();
UO.Print("GetStamina: " + Convert.ToString(value));

Parametri e flusso di esecuzione:

• Viene visualizzata la soglia o il calcolo applicato per questo campo. I numeri nella condizione sono impostazioni di esempio, non limiti del server. Prima di dividere per il massimo se ne controlla la positività.

return  RunScenario();
 object? RunScenario()
{
    var value = UO.GetStamina();
    if (Truth(value < 15))
    {
        UO.Print("Known stamina is below the movement threshold of 15");
    }

    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:

• Questo nome non ha la forma con ID. ReadValue senza parametri legge self; le due chiamate sono separate da UO.Wait(1000). Confrontando due istantanee potrebbero non essere rilevate modifiche intermedie.

return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

    async public Task<object?> RunScenarioAsync()
    {
        var before = ReadValue();
        await Delay(1000);
        var after = ReadValue();
        UO.Print("Before: " + Convert.ToString(before) + "; after: " + Convert.ToString(after));
        return null;
    }

    dynamic ReadValue()
    {
        return UO.GetStamina();
    }

    Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
}

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: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [GetStamina].
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Stamina: bridge.Stamina.

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

Codice interno di implementazione; non è uno script autonomo.

() => bridge.Stamina

Creazione API: Queste funzioni registrano l’API. Non vengono eseguite di nuovo a ogni chiamata del comando.

• InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddInteger.

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

int UO.GetStatLockState(object? statNum);

Legge la modalità di modifica delle caratteristiche locali.

• statNum - Numero caratteristico obbligatorio: 0 - Converti.ToString, 1 - DEX, 2 - INT. Questo non è il suo valore corrente e non il nome della stringa.

int: 0 - aumento, 1 - diminuzione, 2 - blocco. Questo è un codice di modalità, non true/false. Per un numero esterno a 0..2 restituisce −1. Se il carattere manca, per impostazione predefinita viene restituito un numero valido 0; questa non è una conferma dello stato del server.

• La lettura viene effettuata tramite Invoke sul thread di gioco in base ai dati già ricevuti; i pacchetti di rete non vengono inviati. L'abilità non viene utilizzata né allenata. Due richieste: due snapshot separati.
• Numero caratteristico obbligatorio: 0 - STR, 1 - DEX, 2 - INT. Questo non è il suo valore corrente e non il nome della stringa.
• ExecuteClientApiCompatibility seleziona il ramo di comando. Il testo legge il selettore delle abilità, Arg legge i numeri numerici e le modalità. Un argomento non convertibile potrebbe fallire la chiamata con un errore di conversione.

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.GetStatLockState(0);
UO.Print("GetStatLockState: " + Convert.ToString(result));

Parametri e flusso di esecuzione:

• Nell'esempio, il selettore e, durante la registrazione, la modalità sono specificati esplicitamente. La prima riga seleziona un'abilità per nome o una caratteristica per numero. Print visualizza solo il risultato.

var selector = 0;
var mode = UO.GetStatLockState(selector);
UO.Print(Convert.ToString(mode));

Parametri e flusso di esecuzione:

• La soglia 95.1 e le modalità 0/1/2 sono fornite come esempio. −1 viene controllato prima di cambiare modalità. Dopo la scrittura viene letta solo la copia locale; non sta aspettando che il server risponda.

return  RunScenario();
 object? RunScenario()
{
    var mode = UO.GetStatLockState(0);
    if (Truth(mode == 2))
    {
        UO.Print("Locked");
    }
    else
    {
        if (Truth(mode == -1))
        {
            UO.Print("Unknown selector");
        }
        else
        {
            UO.Print("Mode: " + Convert.ToString(mode));
        }
    }

    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:

• Tutto il codice helper è riportato di seguito Main. il selettore seleziona un'abilità/caratteristica, la modalità imposta la modalità di registrazione. ReadValue/ReadMode restituisce il numero originale; ApplyMode controlla gli argomenti, esegue l'azione e non restituisce un valore. UO.Wait(1000) nell'esempio di lettura separa due immagini.

return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

    async public Task<object?> RunScenarioAsync()
    {
        var before = ReadMode(0);
        await Delay(1000);
        var after = ReadMode(0);
        UO.Print(Convert.ToString(before) + " -> " + Convert.ToString(after));
        return null;
    }

    dynamic ReadMode(dynamic selector)
    {
        return UO.GetStatLockState(selector);
    }

    Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
}

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: statNum (Any)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "getstatlockstate": return new InjectionValue(bridge.GetStatLockState(Arg(0)));

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

void UO.GetStatus(object? id);

Invia una richiesta al server per lo stato del mobile specificato.

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

void: nessun valore restituito.

• string-form resolves name via GetObject; The int-form renders serial directly. Il bridge chiama GameActions.RequestMobileStatus(world,serial,true). Il comando non restituisce dati e non attende una risposta. Leggi GetHP/GetMaxHP e altri getter separatamente dopo l'aggiornamento mondiale.

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

Parametri e flusso di esecuzione:

• Una richiesta di stato viene inviata senza attendere una risposta.

UO.GetStatus("self");

Parametri e flusso di esecuzione:

• Il modulo int invia la stessa richiesta.

return  RunScenario();
 object? RunScenario()
{
    var id = UO.Self();
    UO.GetStatus(id);
    return null;
}

Parametri e flusso di esecuzione:

• Una pausa non garantisce una nuova risposta; i getter restituiscono il modello locale corrente.

return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

    async public Task<object?> RunScenarioAsync()
    {
        UO.GetStatus("self");
        await Delay(500);
        UO.Print(Convert.ToString(UO.GetHP()) + "/" + Convert.ToString(UO.GetMaxHP()));
        return null;
    }

    Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
}

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: id (Integer/String)

Risultato: void / Unit.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.GetStatus.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetStatus: bridge.GetStatus(id).

Codice interno di implementazione; non è uno script autonomo.

public void GetStatus(int id) => bridge.GetStatus(id);

Parametri: id (Integer/String)

Risultato: void / Unit.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.GetStatus.
• InjectionScript.Runtime.InjectionApiUO.GetStatus: GetStatus(GetObject(id)).
• InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(id).

Codice interno di implementazione; non è uno script autonomo.

public void GetStatus(string id) => GetStatus(GetObject(id));

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

int UO.GetStr();
int UO.GetStr(object? objID);

Legge la potenza attuale (Strength, Str) del carattere.

• objID — ObjID solo nella forma mostrata, con un argomento: numero di carattere serial, stringa esadecimale decimale/0x, "self", "lasttarget" o nome AddObject. Seleziona un oggetto diverso da graphic/type. Senza argomenti, viene letto il carattere corrente.

int — punti statistici attuali, 0..65535 nel modello client; non percentuale, ID, abilità, modalità di blocco o bool. 0 significa anche carattere mancante/cancellato o oggetto inaccessibile. Confrontare con il requisito numerico, non == true. Questo non è un limite statistico o un valore base garantito senza modificatori.

• Sono supportati () per self e (ObjID) per un oggetto esplicito. Non ci sono altri argomenti facoltativi.
• Legge Player.Strength se Player esiste e non è stato distrutto; altrimenti 0. Un personaggio morto presente non è un oggetto rimosso. La statistica non viene calcolata da HP, mana o resistenza.
• GetStr/GetInt/GetDex accetta ObjID. I dati PlayerMobile sono disponibili solo per self; per un altro serial - 0, anche per mobile caricato. Le caratteristiche di qualcun altro non vengono sostituite o indovinate.
• Invoca letture sul flusso di gioco con la possibilità di annullare l'attesa tramite script. Non interroga lo stato, non apre il target, non invia un pacchetto, non cambia le caratteristiche e non aggiunge ritardo.
• Ogni chiamata legge nuovamente i dati locali. La variabile memorizza l'istantanea; le singole letture potrebbero ricevere diversi aggiornamenti del server. Un risultato diverso da zero non verifica la connessione. Zero può essere un valore o nessun dato.
• C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool. UO.Str(), UO.Strength(), UO.GetStr(), UO.GetStrength().
• ExecuteClientApiCompatibility.Arg prima risolve il nome dell'oggetto, quindi converte il numero. Una stringa non numerica sconosciuta provoca un errore di conversione, non un obiettivo. double è ridotto a int, Array/void è ridotto a 0. Per selezionare un personaggio, usa il serial corretto, non tali trasformazioni.

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.GetStr();
UO.Print("GetStr: " + Convert.ToString(result));

Parametri e flusso di esecuzione:

• value memorizza il risultato numerico; Convert.ToString lo formatta semplicemente per la rivista. Non ci sono argomenti o azioni dei personaggi.

var value = UO.GetStr();
UO.Print("Strength: " + Convert.ToString(value));

Parametri e flusso di esecuzione:

• prima e dopo 1000 ms separati; UO.Wait aggiunto all'esempio. change=after-before può essere positivo, zero o negativo. Di per sé, non distingue tra tutti gli aggiornamenti intermedi e l'uscita dal mondo.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.GetStr();
    await Delay(1000);
    var after = UO.GetStr();
    var change = after - before;
    UO.Print("Change: " + Convert.ToString(change));
    return null;
}

Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));

Parametri e flusso di esecuzione:

• minimo=80 è un esempio di requisito, non di limite del cliente. AttributeAtLeast(minimo) rifiuta il carattere mancante, legge la caratteristica una volta e restituisce bool: true o false se >= minimo. Il significato logico è dato dal confronto, non dalla caratteristica stessa.

return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        if (Truth(Truth(AttributeAtLeast(80)) == true))
        {
            UO.Print("Requirement met");
        }
        else
        {
            UO.Print("Requirement not met or no player");
        }

        return null;
    }

    dynamic AttributeAtLeast(dynamic minimum)
    {
        if (Truth(UO.Self() == 0))
        {
            return false;
        }

        var value = UO.GetStr();
        return value >= minimum;
    }

    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:

• id è il risultato di UO.Self(), non type. AddObject memorizza ID come statSubject senza ambito perché è specificato il secondo argomento. Entrambe le chiamate selezionano lo stesso carattere, ma le letture non sono atomiche.

var id = UO.Self();
if (Truth(id != 0))
{
    UO.AddObject("statSubject", id);
    var direct = UO.GetStr(id);
    var byName = UO.GetStr("statSubject");
    UO.Print("Direct: " + Convert.ToString(direct) + "; alias: " + Convert.ToString(byName));
}

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: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [GetStr].
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Strength: bridge.Strength.

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

Codice interno di implementazione; non è uno script autonomo.

() => bridge.Strength

Creazione API: Queste funzioni registrano l’API. Non vengono eseguite di nuovo a ogni chiamata del comando.

• InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddInteger.

Parametri: objID (Any)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "getstr": return new InjectionValue(arguments.Length > 0 ? bridge.GetStrength(Arg(0)) : bridge.Strength);

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

int UO.GetStrength();

Legge la potenza attuale (Strength, Str) del carattere.

Non ci sono parametri.

int — punti statistici attuali, 0..65535 nel modello client; non percentuale, ID, abilità, modalità di blocco o bool. 0 significa anche carattere mancante/cancellato o oggetto inaccessibile. Confrontare con il requisito numerico, non == true. Questo non è un limite statistico o un valore base garantito senza modificatori.

• Il comando non accetta argomenti. Usa le firme esatte sopra.
• Legge Player.Strength se Player esiste e non è stato distrutto; altrimenti 0. Un personaggio morto presente non è un oggetto rimosso. La statistica non viene calcolata da HP, mana o resistenza.
• GetStr/GetInt/GetDex accetta ObjID. I dati PlayerMobile sono disponibili solo per self; per un altro serial - 0, anche per mobile caricato. Le caratteristiche di qualcun altro non vengono sostituite o indovinate.
• Invoca letture sul flusso di gioco con la possibilità di annullare l'attesa tramite script. Non interroga lo stato, non apre il target, non invia un pacchetto, non cambia le caratteristiche e non aggiunge ritardo.
• Ogni chiamata legge nuovamente i dati locali. La variabile memorizza l'istantanea; le singole letture potrebbero ricevere diversi aggiornamenti del server. Un risultato diverso da zero non verifica la connessione. Zero può essere un valore o nessun dato.
• C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool. UO.Str(), UO.Strength(), UO.GetStr(), UO.GetStrength().

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.GetStrength();
UO.Print("GetStrength: " + Convert.ToString(result));

Parametri e flusso di esecuzione:

• value memorizza il risultato numerico; Convert.ToString lo formatta semplicemente per la rivista. Non ci sono argomenti o azioni dei personaggi.

var value = UO.GetStrength();
UO.Print("Strength: " + Convert.ToString(value));

Parametri e flusso di esecuzione:

• prima e dopo 1000 ms separati; UO.Wait aggiunto all'esempio. change=after-before può essere positivo, zero o negativo. Di per sé, non distingue tra tutti gli aggiornamenti intermedi e l'uscita dal mondo.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.GetStrength();
    await Delay(1000);
    var after = UO.GetStrength();
    var change = after - before;
    UO.Print("Change: " + Convert.ToString(change));
    return null;
}

Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));

Parametri e flusso di esecuzione:

• minimo=80 è un esempio di requisito, non di limite del cliente. AttributeAtLeast(minimo) rifiuta il carattere mancante, legge la caratteristica una volta e restituisce bool: true o false se >= minimo. Il significato logico è dato dal confronto, non dalla caratteristica stessa.

return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        if (Truth(Truth(AttributeAtLeast(80)) == true))
        {
            UO.Print("Requirement met");
        }
        else
        {
            UO.Print("Requirement not met or no player");
        }

        return null;
    }

    dynamic AttributeAtLeast(dynamic minimum)
    {
        if (Truth(UO.Self() == 0))
        {
            return false;
        }

        var value = UO.GetStrength();
        return value >= minimum;
    }

    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: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [GetStrength].
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Strength: bridge.Strength.

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

Codice interno di implementazione; non è uno script autonomo.

() => bridge.Strength

Creazione API: Queste funzioni registrano l’API. Non vengono eseguite di nuovo a ogni chiamata del comando.

• InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddInteger.

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

dynamic UO.GetTitle(object? objID);

Legge il titolo del personaggio noto al cliente: ad esempio professione o firma dopo il nome.

• objID — Richiesto l'oggetto serial/ID, non type e non cliloc. Accetta int, stringa decimale/esadecimale, self, backpack, lasttarget, trovaelemento o nome AddObject. 0 significa nessun oggetto.

string — testo del campo Titolo per dispositivi mobili. Stringa vuota se il titolo è sconosciuto, l'oggetto non è un carattere o manca ID. Non è serial, un nome completo o un array di proprietà. GetAltName utilizza lo stesso campo di GetTitle.

• La chiamata stessa legge i dati locali, non attende il server e non invia un solo clic. Per richiedere un nome/titolo utilizzare da solo ClickOnObject; la risposta arriva in modo asincrono.
• Per un carattere esistente è accettabile anche una stringa vuota. Il controllo Exists risponde ad un'altra domanda: se l'oggetto è caricato.
• In questa implementazione, il nome alternativo viene mappato nel campo Titolo del personaggio.

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

Parametri e flusso di esecuzione:

• ObjID=self — carattere del client corrente.
• titolo contiene solo il titolo; un campo vuoto non significa un errore di script.

var title = UO.GetTitle("self");
UO.Print(title);

Parametri e flusso di esecuzione:

• ObjID=id — serial dell'ultimo target. GetName e il titolo vengono letti separatamente.
• La destinazione dell'elemento non ha un campo Titolo e fornirà una stringa vuota.

return  RunScenario();
 object? RunScenario()
{
    var id = UO.GetSerial("lasttarget");
    if (Truth(UO.Exists(id)))
    {
        var title = UO.GetTitle(id);
        if (Truth(title != ""))
        {
            UO.Print(UO.GetName(id) + " " + title);
        }
    }

    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:

• 350 — esempio di pausa in millisecondi dopo un singolo clic; questo non è un parametro getter.
• Il server potrebbe rispondere più tardi o non trasferire il titolo. Conserva la gestione della stringa vuota.

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.GetSerial("lasttarget");
        if (Truth(UO.Exists(id)))
        {
            UO.ClickOnObject(id);
            UO.Wait(350);
            UO.Print(UO.GetTitle(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: objID (Any)

Risultato: dynamic / Any.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "gettitle": return new InjectionValue(bridge.GetTitle(Arg(0, bridge.Self)));

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

int UO.GetWeight();

Legge il contatore dello stato del tuo personaggio: peso attuale in pietre.

Non ci sono parametri.

int — peso attuale in pietre, 0..65535 nel modello client. 0 può essere un valore reale, nessun dato o un giocatore scomparso/distrutto. Questa è una quantità, non bool, ID o type: 1 significa un'unità, non successo. Il comando non esegue iterazioni sugli oggetti e non restituisce un array.

• Il comando non accetta argomenti. Usa le firme esatte sopra.
• La lettura nel thread del gioco richiede Player.Weight se il Player attuale esiste e non è stato distrutto; altrimenti 0. L'attrezzatura non viene ordinata, i bonus non vengono ricalcolati, lo status non viene richiesto e non c'è attesa per gli aggiornamenti. Un fantasma presente non è uguale ad un Giocatore distrutto.
• Weight legge il peso totale riportato dal server in pietre. Il peso del corpo, dell'attrezzatura e delle borse incluse nell'importo è determinato dalle regole dello Shard. Il team non attraversa i contenitori, non somma il peso degli articoli o aggiorna i bagagli chiusi. Questa non è la proprietà Weight di un singolo articolo, né il numero di articoli.
• CharacterStatus controlla il corpo richiesto prima dell'aggiornamento. Weight è disponibile nel suo stato esteso, slot - da type 3, Luck - da type 4, server WeightMax - da type 5. Un pacchetto compatto/vecchio senza un contatore opzionale lascia la cache precedente. Il nuovo Player inizia da zero; la chiamata non dimostra il ricevimento di un nuovo status.
• Queste funzioni registrano l’API. Non vengono eseguite di nuovo a ogni chiamata del comando. C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.
• Ogni chiamata legge nuovamente i dati locali. La variabile memorizza l'istantanea; le singole letture potrebbero ricevere diversi aggiornamenti del server. Un risultato diverso da zero non verifica la connessione. Zero può essere un valore o nessun dato.

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.GetWeight();
UO.Print("GetWeight: " + Convert.ToString(result));

Parametri e flusso di esecuzione:

• value memorizza una chiamata senza argomento al proprio carattere; Convert.ToString formatta il numero del log senza cambiarne il significato.

var value = UO.GetWeight();
UO.Print("Weight: " + Convert.ToString(value));

Parametri e flusso di esecuzione:

• UO.Wait(500) separa il prima e il dopo di 500 millisecondi. difference can be positive, zero or negative; Gli aggiornamenti temporanei e le modifiche ai personaggi potrebbero essere saltati. La pausa è un esempio.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.GetWeight();
    await Delay(500);
    var after = UO.GetWeight();
    var difference = after - before;
    UO.Print("Counter change: " + Convert.ToString(difference));
    return null;
}

Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));

Parametri e flusso di esecuzione:

• CanCarry(extra) ottiene un peso extra in pietre; 10 è un esempio, non il numero di stack. Rifiuta extra negativo, nessun giocatore o massimo <= 0, legge il peso e il limite attuali, quindi restituisce bool: true o false con extra <= massimo - corrente. La sottrazione evita l'eccesso di corrente + extra. In caso di sovraccarico, il risultato è false anche per extra=0. Questa è una valutazione locale, non una risoluzione del server; le letture non sono atomiche e il peso zero potrebbe essere sconosciuto.

return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        if (Truth(Truth(CanCarry(10)) == true))
        {
            UO.Print("Local check passed");
        }
        else
        {
            UO.Print("Local check failed or data unavailable");
        }

        return null;
    }

    dynamic CanCarry(dynamic extra)
    {
        if (Truth(extra < 0) || Truth(UO.Self() == 0))
        {
            return false;
        }

        var current = UO.GetWeight();
        var maximum = UO.MaxWeight();
        if (Truth(maximum <= 0))
        {
            return false;
        }

        return extra <= maximum - current;
    }

    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: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.Weight.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Weight: bridge.Weight.

Codice interno di implementazione; non è uno script autonomo.

public int Weight() => bridge.Weight;

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

int UO.GetYellowBar(object? id);

Controlla il flag giallo della barra della salute mobile.

• id — Obbligatorio serial/ID di un oggetto specifico: int, stringa esadecimale o alias self, backpack, lasttarget, lastobject, lastcontainer, laststatus, finditem, lastcorpse o nome AddObject. Questo non è graphic/type. Il nome non specificato si risolve in 0; il comando non apre alcuna nuova destinazione. L'argomento è obbligatorio; per te, supera self.

int 1 - caricato mobile ha l'attributo IsYellowHits. int 0 - manca l'attributo, l'oggetto non è mobile, sconosciuto o eliminato. Questo è un flag server/compatibile, non un colore del tema IDE o una quantità HP. L'assenza di un flag non dimostra vulnerabilità: il server può indicare la protezione in modo diverso.

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

• Viene letto il modello client locale; Non ci sono richieste al server, nessuna attesa o spostamento.
• Il risultato si riferisce al momento della lettura. Dopo UO.Wait o altra azione, l'oggetto e i suoi flag potrebbero cambiare.
• Questo è un flag server/compatibile, non il colore del tema IDE o la quantità HP. L'assenza di un flag non dimostra vulnerabilità: il server può indicare la protezione in modo diverso.

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.GetYellowBar("self");
UO.Print("GetYellowBar: " + Convert.ToString(result));

Parametri e flusso di esecuzione:

• L'argomento self seleziona esplicitamente il suo carattere. stato - solo 1/0.
• Questo è un flag server/compatibile, non il colore del tema IDE o la quantità HP. L'assenza di un flag non dimostra vulnerabilità: il server può indicare la protezione in modo diverso.

var state = UO.GetYellowBar("self");
var hp = UO.GetHP("self");
UO.Print("Yellow flag: " + Convert.ToString(state));
UO.Print("Known HP: " + Convert.ToString(hp));

Parametri e flusso di esecuzione:

• IsNpc esclude soggetto e oggetto sconosciuto. target memorizza un singolo serial anziché un riferimento live a un lasttarget mutevole.
• Il risultato si riferisce al campo IsYellowHits. I dati vengono aggiornati solo dopo che il client ha ricevuto lo stato appropriato.

return  RunScenario();
 object? RunScenario()
{
    var target = UO.GetSerial("lasttarget");
    if (Truth(UO.IsNPC(target)))
    {
        var state = UO.GetYellowBar(target);
        UO.Print("Selected mobile state 1/0: " + Convert.ToString(state));
    }
    else
    {
        UO.Print("No loaded mobile selected");
    }

    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:

• UO.Wait(500): pausa in millisecondi. Successivamente, viene controllato separatamente che mobile esista ancora.
• Vengono confrontate due immagini. Le modifiche intermedie potrebbero non essere perse e questa non è una sottoscrizione continua agli eventi del server.

return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

    async public Task<object?> RunScenarioAsync()
    {
        var target = UO.GetSerial("lasttarget");
        if (Truth(UO.IsNPC(target)))
        {
            var before = UO.GetYellowBar(target);
            await Delay(500);
            if (Truth(UO.IsNPC(target)))
            {
                var after = UO.GetYellowBar(target);
                if (Truth(before != after))
                {
                    UO.Print("Flag changed: " + Convert.ToString(before) + " -> " + Convert.ToString(after));
                }
            }
            else
            {
                UO.Print("Mobile left the local world");
            }
        }

        return null;
    }

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

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: id (Any)

Risultato: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.GetYellowBar.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetYellowBar: bridge.GetYellowBar(GetObject(id)).
• InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(id).

Codice interno di implementazione; non è uno script autonomo.

public int GetYellowBar(InjectionValue id) => bridge.GetYellowBar(GetObject(id));

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

dynamic UO.Gold();

Legge la quantità di oro dallo stato attuale del personaggio.

Non ci sono parametri.

int/double — somma non negativa 0..4294967295. Fino a 2147483647 compreso, viene restituito un int, sopra - un double (Double), che rappresenta esattamente qualsiasi intero senza segno 32 bit. 0 significa anche nessun giocatore attualmente non eliminato o importo ricevuto. Non è bool, ID, numero di stack o attraversamento di zaino/banca.

• Non ci sono parametri. Legge la cache Player.Gold da CharacterStatus (0x11). Il server determina quale oro è incluso nel suo contatore; la squadra non fruga le borse né chiede saldi bancari. Nessun giocatore/giocatore distrutto - 0; un regalo fantasma può mantenere un importo di status.
• ReadGoldValue legge bridge.Gold una volta. Il vecchio bridge C# mantiene la firma Int32 e trasmette bit UInt32. la conversione non controllata ripristina la somma senza segno; una piccola quantità diventa int, una grande quantità diventa double. La parte più significativa non rende più il saldo negativo. La conversione è locale, non ci sono pacchetti.
• Ogni chiamata legge nuovamente i dati locali. La variabile memorizza l'istantanea; le singole letture potrebbero ricevere diversi aggiornamenti del server. Un risultato diverso da zero non verifica la connessione. Zero può essere un valore o nessun dato.

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

Parametri e flusso di esecuzione:

• importo memorizza un risultato; Convert.ToString lo formatta per la rivista. L’oro non viene cercato, trasportato o speso.

var amount = UO.Gold();
UO.Print("Status gold: " + Convert.ToString(amount));

Parametri e flusso di esecuzione:

• price=3000000000.0 è un esempio di prezzo, non di limite. CanAfford(prezzo) rifiuta un prezzo negativo o nessun giocatore, legge l'importo una volta e restituisce bool: true o false se importo >= prezzo. L'importo in sé non è bool. La funzione è completamente definita di seguito.

return  RunScenario();
 object? RunScenario()
{
    var price = 3000000000.0;
    if (Truth(Truth(CanAfford(price)) == true))
    {
        UO.Print("Local balance is sufficient");
    }
    else
    {
        UO.Print("Local check failed");
    }

    return null;
}

dynamic CanAfford(dynamic price)
{
    if (Truth(price < 0) || Truth(UO.Self() == 0))
    {
        return false;
    }

    var amount = UO.Gold();
    return amount >= price;
}

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:

• prima/dopo separa UO.Wait(500) millisecondi. differenza=dopo-prima può essere negativa quando il saldo diminuisce; Non si tratta di un overflow del contatore fisso senza segno. Potrebbero mancare aggiornamenti temporanei e modifiche ai personaggi.

return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

    async public Task<object?> RunScenarioAsync()
    {
        var before = UO.Gold();
        await Delay(500);
        var after = UO.Gold();
        var difference = after - before;
        UO.Print("Balance change: " + Convert.ToString(difference));
        return null;
    }

    Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
}

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.ReadGoldValue: ReadGoldValue().

Codice interno di implementazione; non è uno script autonomo.

case "gold": return ReadGoldValue();

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

int UO.HP();

Legge l'integrità attuale dal modello locale.

Non ci sono parametri.

int è il valore del campo Hits, non la percentuale e non bool. 0 può essere un valore reale o un'indicazione di dati mancanti. Il massimo zero non può essere utilizzato come divisore. Per mobile di qualcun altro i significati potrebbero essere sconosciuti. HP/HitsMax può contenere la scala relativa del server anziché i punti esatti. HP=0 non prova la morte; c'è Dead/IsDead per questo.

• Il comando non apre lo stato e non richiede un aggiornamento del server. Il client legge solo i dati già caricati. Non cambia caratteristiche e non invia pacchetti.
• Il risultato è una lettura separata. Il mondo può cambiare tra Exists e la prossima sfida; più query non formano uno snapshot atomico.
• Durante la lettura di un oggetto, World.Get rifiuta l'o mancante o IsDestroyed e risulta in 0. HP/HitsMax vengono letti dall'Entità, inclusi gli elementi con questi campi; Mana/Stamina - solo per dispositivi mobili. Senza discutere, leggi self. La variante con lo stesso nome senza parametri non ha necessariamente una variante con ID: vedi firme.
• La lettura senza argomenti restituisce anche 0 per un giocatore scomparso o distrutto. Questo vale anche per Mana/Stamina diretti e i loro massimi, non solo per le forme World.Get. Un personaggio morto presente può conservare valori.

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.HP();
UO.Print("HP: " + Convert.ToString(result));

Parametri e flusso di esecuzione:

• La chiamata senza argomenti legge self. value memorizza un numero, Convert.ToString lo converte solo per il messaggio.

var value = UO.HP();
UO.Print("HP: " + Convert.ToString(value));

Parametri e flusso di esecuzione:

• Viene visualizzata la soglia o il calcolo applicato per questo campo. I numeri nella condizione sono impostazioni di esempio, non limiti del server. Prima di dividere per il massimo se ne controlla la positività.

return  RunScenario();
 object? RunScenario()
{
    var value = UO.HP();
    var maximum = UO.GetMaxHP();
    if (Truth(maximum > 0) && Truth(value * 100 / maximum < 50))
    {
        UO.Print("Health below half of the known maximum");
    }

    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:

• Questo nome non ha la forma con ID. ReadValue senza parametri legge self; le due chiamate sono separate da UO.Wait(1000). Confrontando due istantanee potrebbero non essere rilevate modifiche intermedie.

return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

    async public Task<object?> RunScenarioAsync()
    {
        var before = ReadValue();
        await Delay(1000);
        var after = ReadValue();
        UO.Print("Before: " + Convert.ToString(before) + "; after: " + Convert.ToString(after));
        return null;
    }

    dynamic ReadValue()
    {
        return UO.HP();
    }

    Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
}

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: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [HP].
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetHP: bridge.GetHP(bridge.Self).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self: bridge.Self.

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

Codice interno di implementazione; non è uno script autonomo.

() => bridge.GetHP(bridge.Self)

Creazione API: Queste funzioni registrano l’API. Non vengono eseguite di nuovo a ogni chiamata del comando.

• InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddInteger.

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

int UO.Hidden();
int UO.Hidden(object? id);

Mette alla prova la furtività del personaggio.

• id — Oggetto opzionale nei moduli visualizzati: serial per numero/stringa esadecimale, self, lasttarget o nome registrato AddObject. Questo non è type. Senza discutere, leggi self. Il testo sconosciuto in alcuni moduli causa un errore di conversione; controlla il nome prima di chiamare.

Flag numerico int: 1 (condizione soddisfatta), 0 (condizione non soddisfatta). Questo è un flag numerico: in C# controlla risultato != 0 o risultato == 0. Il confronto diretto di int con true/false e if (risultato) non è consentito. 1 - mobile ha IsHidden, 0 non ha flag o mobile manca. Questa è una bandiera del server, non una visibilità dietro un muro.

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

• Legge il modello locale: non apre il target, non richiede lo stato, non cambia il flag e non invia il pacchetto. Un oggetto distrutto è considerato mancante anche prima che la voce venga cancellata dal dizionario.
• Il risultato è una lettura separata. Il mondo può cambiare tra Exists e la prossima sfida; più query non formano uno snapshot atomico.

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.Hidden();
UO.Print("Hidden: " + Convert.ToString(result));

Parametri e flusso di esecuzione:

• Le parentesi vuote leggono self. attivo salva il risultato una volta; true e false definiscono due rami. Print visualizza solo un messaggio di esempio.

var active = UO.Hidden();
if (Truth(Truth(active) == true))
{
    UO.Print("State is active");
}
else
{
    UO.Print("State is inactive or unavailable");
}

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:

• lasttarget – oggetto precedentemente selezionato. Exists ne verifica la presenza. obj è l'unico parametro ReadState; la funzione restituisce il risultato del comando senza modifiche. La sua definizione è inclusa nel codice copiato.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Exists("lasttarget")))
    {
        var observed = ReadState("lasttarget");
        UO.Print("State 1/0: " + Convert.ToString(observed));
    }

    return null;
}

dynamic ReadState(dynamic obj)
{
    return UO.Hidden(obj);
}

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:

• Due chiamate senza argomenti leggono self, UO.Wait(500) imposta 500 millisecondi. Vengono confrontate due immagini; le transizioni intermedie possono essere saltate. Non esiste un'attesa infinita.

return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

    async public Task<object?> RunScenarioAsync()
    {
        var before = UO.Hidden();
        await Delay(500);
        var after = UO.Hidden();
        if (Truth(before != after))
        {
            UO.Print("State changed: " + Convert.ToString(before) + " -> " + Convert.ToString(after));
        }

        return null;
    }

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

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: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.Hidden.
• InjectionScript.Runtime.InjectionApiUO.Hidden: Hidden("self").

Codice interno di implementazione; non è uno script autonomo.

public int Hidden() => Hidden("self");

Parametri: id (Integer/String)

Risultato: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.Hidden.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Hidden: bridge.Hidden(id).

Codice interno di implementazione; non è uno script autonomo.

public int Hidden(int id) => bridge.Hidden(id);

Parametri: id (Integer/String)

Risultato: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.Hidden.
• InjectionScript.Runtime.InjectionApiUO.Hidden: Hidden(GetObject(idText)).
• InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(idText).

Codice interno di implementazione; non è uno script autonomo.

public int Hidden(string idText) => Hidden(GetObject(idText));

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

int UO.Int();

Legge l'intelligenza attuale (Intelligence, INT) del personaggio.

Non ci sono parametri.

int — punti statistici attuali, 0..65535 nel modello client; non percentuale, ID, abilità, modalità di blocco o bool. 0 significa anche carattere mancante/cancellato o oggetto inaccessibile. Confrontare con il requisito numerico, non == true. Questo non è un limite statistico o un valore base garantito senza modificatori.

• Il comando non accetta argomenti. Usa le firme esatte sopra.
• Legge Player.Intelligence se Player esiste e non è stato distrutto; altrimenti 0. Un personaggio morto presente non è un oggetto rimosso. La statistica non viene calcolata da HP, mana o resistenza.
• GetStr/GetInt/GetDex accetta ObjID. I dati PlayerMobile sono disponibili solo per self; per un altro serial - 0, anche per mobile caricato. Le caratteristiche di qualcun altro non vengono sostituite o indovinate.
• Invoca letture sul flusso di gioco con la possibilità di annullare l'attesa tramite script. Non interroga lo stato, non apre il target, non invia un pacchetto, non cambia le caratteristiche e non aggiunge ritardo.
• Ogni chiamata legge nuovamente i dati locali. La variabile memorizza l'istantanea; le singole letture potrebbero ricevere diversi aggiornamenti del server. Un risultato diverso da zero non verifica la connessione. Zero può essere un valore o nessun dato.
• C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool. UO.Int(), UO.Intelligence(), UO.GetInt(), UO.GetIntelligence().

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.Int();
UO.Print("Int: " + Convert.ToString(result));

Parametri e flusso di esecuzione:

• value memorizza il risultato numerico; Convert.ToString lo formatta semplicemente per la rivista. Non ci sono argomenti o azioni dei personaggi.

var value = UO.Int();
UO.Print("Intelligence: " + Convert.ToString(value));

Parametri e flusso di esecuzione:

• prima e dopo 1000 ms separati; UO.Wait aggiunto all'esempio. change=after-before può essere positivo, zero o negativo. Di per sé, non distingue tra tutti gli aggiornamenti intermedi e l'uscita dal mondo.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.Int();
    await Delay(1000);
    var after = UO.Int();
    var change = after - before;
    UO.Print("Change: " + Convert.ToString(change));
    return null;
}

Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));