Українська · Русский · 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 · 繁體中文 · 日本語 · 한국어

dynamic UO.GetEquipment(object? id);

Legge l'elenco delle apparecchiature su livelli di oggetti diversi da zero.

• id — Seriale/ID di un oggetto specifico: int, stringa decimale/esadecimale o set alias self, backpack, lasttarget, lastobject o nome AddObject. Questo non è graphic/type. Le righe my/backpack selezionano lo zaino. Seleziona solo il terreno esplicito 0, "0" o "ground". Un alias sconosciuto, uno zaino mancante, un ID negativo o un tipo di valore inappropriato risultano in un array vuoto.

Array - serial di ciascun elemento il cui contenitore è ID e il livello non è uguale a Non valido. Per ground/0 viene restituito un Array vuoto. Senza voci, viene restituito un Array vuoto. L'elenco contiene ID, non type e nessun livello.

• Vengono letti i dati già scaricati dal client. Il comando non apre il contenitore, non sposta elementi né scarica oggetti dall'intero server.
• Array - array con indici a partire da 0. Salvalo in var, controlla ArrayLength prima di accedere. Gli elementi potrebbero scomparire dal mondo dopo aver scattato una foto: controlla Exists(serial) prima di agire.
• Non è previsto l'attraversamento ricorsivo di sacchetti annidati, l'ordinamento della distanza, il filtro Ignore o FindDistance/FindVertical. La normale istantanea FindType rimane invariata.
• GetEquipment(self) include lo zaino e altri strati noti diversi da zero; Il semplice fatto di uno strato non significa che si indossa un'arma o un'armatura. GetContent(self) può includere equipaggiamento perché il suo genitore è un 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.GetEquipment("self");
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

Parametri e flusso di esecuzione:

• ID="self" - vengono selezionati il ​​personaggio corrente, i suoi oggetti diretti con un Livello diverso da zero.
• Lunghezza - numero di record/ID. Questo non è l'importo dell'importo in pile. L'elenco vuoto dà 0.

var items = UO.GetEquipment("self");
UO.Print(Convert.ToString(ArrayLength(items)));

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

Parametri e flusso di esecuzione:

• ID="self" - vengono selezionati il ​​personaggio corrente, i suoi oggetti diretti con un Livello diverso da zero.
• elementi[i] — numerico serial. Hex viene utilizzato solo per l'output. Il ciclo non accede all'ultimo indice.

return  RunScenario();
 object? RunScenario()
{
    var items = UO.GetEquipment("self");
    var i = 0;
    while (Truth(i < ArrayLength(items)))
    {
        UO.Print("0x" + Hex(items[i]));
        i = i + 1;
    }

    return null;
}

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

Parametri e flusso di esecuzione:

• ID="self" - vengono selezionati il ​​personaggio corrente, i suoi oggetti diretti con un Livello diverso da zero.
• Vengono controllate due cose diverse: il record nell'istantanea e l'esistenza dell'oggetto adesso. L'ordine senza una cernita esplicita non significa vicinanza.

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

     public object? RunScenario()
    {
        var items = UO.GetEquipment("self");
        if (Truth(ArrayLength(items) > 0))
        {
            var first = items[0];
            if (Truth(UO.Exists(first)))
            {
                UO.Print(UO.GetName(first));
            }
        }
        else
        {
            UO.Print("Empty list");
        }

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

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: dynamic / Any.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Text: Text(0).
• InjectionScript.Runtime.NumberConversions.TryStr2Int: NumberConversions.TryStr2Int(text, out int literal).
• InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(text).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetEquipment: bridge.GetEquipment(container).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetContent: bridge.GetContent(container).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Backpack: bridge.Backpack.

Codice interno di implementazione; non è uno script autonomo.

case "getcontent":

                case "getequipment":

                {

                    InjectionValue selection = arguments[0];

                    bool ground = false, explicitZero;

                    int container;

                    if (selection.Kind == InjectionValueKind.String)

                    {

                        string text = Text(0).Trim();

                        ground = text.Equals("ground", StringComparison.OrdinalIgnoreCase);

                        explicitZero = NumberConversions.TryStr2Int(text, out int literal) && literal == 0;

                        container = ground ? 0 : text.Equals("my", StringComparison.OrdinalIgnoreCase)

                            ? bridge.Backpack : GetObject(text);

                    }

                    else

                    {

                        if (selection.Kind != InjectionValueKind.Integer && selection.Kind != InjectionValueKind.Decimal)

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

                        container = Arg(0);

                        explicitZero = selection.Kind == InjectionValueKind.Integer ? selection.Integer == 0 : selection.Decimal == 0d;

                    }

                    // Only an explicit ground/zero selector may query world items.

                    if (container < 0 || container == 0 && !ground && !explicitZero)

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

                    bool equipment = name.Equals("GetEquipment", StringComparison.OrdinalIgnoreCase);

                    int[] items = equipment

                        ? container == 0 ? Array.Empty<int>() : bridge.GetEquipment(container)

                        : bridge.GetContent(container);

                    return new InjectionValue(items.Select(serial => new InjectionValue(serial)).ToArray());

                }

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

int UO.GetFireResist();

Legge il campo di resistenza del personaggio attuale: fuoco.

Non ci sono parametri.

int: valore dello stato con segno, -32768..32767 nel modello client. Il valore negativo viene mantenuto. 0 può essere resistenza reale, mancanza di dati o giocatore scomparso/distrutto; GetResist fornisce anche 0 per un selettore sconosciuto. Questo non è un bool, ID, limite di abilità o resistenza. 1 significa un punto, non un successo.

• Il comando non accetta argomenti. Usa le firme esatte sopra.
• La lettura nel thread del gioco richiede Player.FireResistance 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.
• I campi elementari sono estesi CharacterStatus (0x11), type >= 4. Il comando stesso non controlla l'epoca del server. Lo stato compatto/vecchio senza questi campi lascia la cache precedente; Il nuovo Giocatore è inizialmente 0. La Resistenza al Veleno non è una bandiera Poisoned; Inoltre non è un'abilità di resistenza agli incantesimi.
• CharacterStatus controlla il corpo richiesto prima di modificare il nome, la salute e le proprie caratteristiche, quindi traduce ogni parola di resistenza in una parola firmata Int16. Un corpo obbligatorio tagliato non modifica i dati precedenti. La coda opzionale type 6 mantiene le stesse regole; i comandi di resistenza non leggono i limiti massimi da esso.
• 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.
• 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 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.GetFireResist();
UO.Print("GetFireResist: " + Convert.ToString(result));

Parametri e flusso di esecuzione:

• value memorizza il risultato di una chiamata. Convert.ToString formatta il numero per il registro. Non ci sono argomenti: puoi leggere il tuo personaggio.

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

Parametri e flusso di esecuzione:

• Tra prima e dopo ci sono UO.Wait(500) millisecondi; difference can be negative. Interim updates may be missed. La pausa si riferisce all'esempio, non al ritardo API.

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

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

Parametri e flusso di esecuzione:

• minimo=50 è un esempio di requisito, non di limite del cliente. ResistanceAtLeast rifiuta il Giocatore mancante, legge un valore e restituisce bool: true o false se valore >= minimo. La resistenza stessa non è bool. La funzione è completamente dichiarata di seguito.

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(ResistanceAtLeast(50)) == true))
        {
            UO.Print("Local resistance requirement met");
        }
        else
        {
            UO.Print("Requirement not met or no player");
        }

        return null;
    }

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

        var value = UO.GetFireResist();
        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 [GetFireResist].
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.FireResistance: bridge.FireResistance.

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

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.GetFlying();
int UO.GetFlying(object? value);

Controlla se il personaggio sta attualmente volando. Questo di solito è necessario per Gargoyle: ad esempio prima di iniziare una rotta o prima di richiedere l'abilitazione di un volo. Risponde alla domanda "il mio personaggio sta volando adesso?" senza discussione. Il comando legge solo lo stato: non abilita il volo, l'atterraggio o il movimento del personaggio.

• value - Carattere serial opzionale: numero, stringa esadecimale, self, lasttarget o nome memorizzato tramite UO.AddObject. Senza discussione, il tuo personaggio viene utilizzato. Questo è ID dello specifico mobile, non graphic/type e non la coordinata di Z. Un nome sconosciuto, mancante/rimosso mobile o un elemento dà 0.

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 IsFlying, 0 non ha flag o mobile manca. L'altitudine Z di per sé non significa volo.

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.

• La principale applicazione di gioco è il volo di Gargoyle. Il getter però non controlla la corsa: in questo client legge il bit 0x04 del mobile con versione del protocollo 7.0.0.0 e successive. Sul vecchio protocollo restituisce 0. Stare su un tetto, la Z alta, le animazioni delle ali o la stessa corsa dei Gargoyle non sono prova che il volo sia abilitato.
• C'è un UO.ToggleFly() separato per cambiare stato: invia una richiesta di commutazione anziché un comando di "accensione". Se stai già volando, una chiamata ripetuta richiede l'atterraggio. Il server potrebbe non funzionare; dopo la richiesta, leggere nuovamente Flying con un'attesa limitata. false è possibile anche senza personaggi/dati disponibili, quindi controlla Connected prima di giocare.
• 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.GetFlying();
UO.Print("GetFlying: " + Convert.ToString(result));

Parametri e flusso di esecuzione:

• Le parentesi vuote indicano self. true è uguale a 1, false è uguale a 0; se UO.Flying() { ... } è accettabile. Questo esempio non cambia nulla.

var active = UO.GetFlying();
if (Truth(Truth(active) == true))
{
    UO.Print("Flying mode active");
}
else
{
    UO.Print("Ground mode or character data 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:

• ReadState(obj) prende serial/alias e restituisce lo stato. La definizione completa è riportata di seguito; l'assenza di un oggetto viene gestita prima della lettura. Anche il carattere di qualcun altro viene controllato rispetto ai dati già ricevuti dal client.

return  RunScenario();
 object? RunScenario()
{
    var target = Asc(UO.GetSerial("lasttarget"), 0);
    if (Truth(target != 0) && Truth(UO.Exists(target)))
    {
        if (Truth(ReadState(target)))
        {
            UO.AddObject("flying_mobile", target);
        }
    }

    return null;
}

dynamic ReadState(dynamic obj)
{
    if (!(Truth(UO.Exists(obj))))
    {
        return false;
    }

    return UO.GetFlying(obj);
}

int Asc(object? value, int fallback = 0)
{
    string text = Convert.ToString(value) ?? "";
    if (text.StartsWith("0x", StringComparison.OrdinalIgnoreCase))
        return int.TryParse(text[2..], System.Globalization.NumberStyles.HexNumber, System.Globalization.CultureInfo.InvariantCulture, out int hex) ? hex : fallback;
    return int.TryParse(text, out int number) ? number : fallback;
}

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

Parametri e flusso di esecuzione:

• L'esempio è per il tuo Gargoyle su un server che supporta il volo. EnsureFlight(timeoutMs) restituisce 1/true se si osserva il volo, altrimenti 0/false. 2000 — limite di attesa in millisecondi; controlla ogni 50 ms. Se stai già volando, ToggleFly non viene chiamato. Viene inviata al massimo una richiesta, poi viene controllato lo stato della risposta. La pausa dello script/il ritardo della pianificazione può aumentare il tempo reale.

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()
    {
        if (Truth(await EnsureFlight(2000)))
        {
            UO.Print("Flight confirmed; ready for the next stage");
        }
        else
        {
            UO.Print("Flight not confirmed; route was not started");
        }

        return null;
    }

    async Task<dynamic> EnsureFlight(dynamic timeoutMs)
    {
        if (!(Truth(UO.Connected())) || Truth(UO.Dead()))
        {
            return false;
        }

        if (Truth(UO.GetFlying()))
        {
            return true;
        }

        UO.ToggleFly();
        var waited = 0;
        while (Truth(waited < timeoutMs))
        {
            if (!(Truth(UO.Connected())))
            {
                return false;
            }

            if (Truth(UO.GetFlying()))
            {
                return true;
            }

            await Delay(50);
            waited += 50;
        }

        return UO.GetFlying();
    }

    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 [GetFlying].
• InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Flying: bridge.Flying(serial).
• 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.

serial => bridge.Flying(serial)

Codice interno di implementazione; non è uno script autonomo.

() => getter(bridge.Self)

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

• InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddState.

Parametri: value (Any)

Risultato: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [GetFlying].
• InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Flying: bridge.Flying(serial).
• InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(value).

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.

serial => bridge.Flying(serial)

Codice interno di implementazione; non è uno script autonomo.

value => getter(GetObject(value))

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

• InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddState.

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

int UO.GetFrozen();
int UO.GetFrozen(object? value);

Controlla il flag di paralisi del personaggio noto al client.

• value - Opzionale serial/ID mobile: numero, stringa esadecimale, self, lasttarget o altro nome di oggetto standard o nome AddObject. Questo non è graphic/type. Senza argomento, viene utilizzato self. Il nome sconosciuto viene risolto in 0; l'obiettivo non si apre.

Flag numerico int: 1 (condizione soddisfatta) - caricato mobile ha flag IsParalyzed; 0 (condizione non soddisfatta) - nessun flag, mobile sconosciuto, eliminato o l'oggetto è un elemento. Questo non è un momento di paralisi e non garantisce la capacità di muoversi con un risultato di 0.

• Usa Paralyzed per controllare la bandiera della paralisi. Le opzioni Is/Get, GetParalisa, Frozen e GetLocked leggono lo stesso flag.
• Il comando legge solo i dati locali. Non applica né rimuove la paralisi, non ne attende la fine e non invia una richiesta di aggiornamento al server.
• Il risultato di questo comando è di tipo int: usa if (valore != 0) o if (valore == 0). Non sono consentiti confronti diretti con true/false e if (valore) in C#. Il valore conserva il significato del flag, non la quantità o ID.

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

Parametri e flusso di esecuzione:

• Le parentesi vuote selezionano self. lo stato memorizza un'istantanea della bandiera; true è la costante numerica 1.
• Un risultato di false non esclude un muro, mancanza di resistenza o altro motivo per fermarsi.

var state = UO.GetFrozen();
if (Truth(Truth(state) == true))
{
    UO.Print("Paralysis flag is set");
}
else
{
    UO.Print("Paralysis flag is absent 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:

• target memorizza la stringa esadecimale serial dell'ultimo target. IsNpc controlla che sia il mobile caricato, giocatori compresi.
• Il comando con l'argomento legge target. Non sceglie un nuovo personaggio né cambia lasttarget.

return  RunScenario();
 object? RunScenario()
{
    var target = UO.GetSerial("lasttarget");
    if (Truth(UO.IsNPC(target)))
    {
        var state = UO.GetFrozen(target);
        UO.Print("Selected mobile paralysis 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:

• Non più di 10 pause per 100 ms. Ogni chiamata senza argomento rilegge self.
• Dopo il ciclo, la presenza di self viene controllata separatamente. Questa è un'osservazione per circa un secondo più l'esecuzione dei comandi e non una rimozione garantita della paralisi.

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 attempts = 0;
        while (Truth(Truth(UO.GetFrozen()) == true) && Truth(attempts < 10))
        {
            await Delay(100);
            attempts = attempts + 1;
        }

        if (Truth(UO.IsNPC("self")))
        {
            if (Truth(Truth(UO.GetFrozen()) == false))
            {
                UO.Print("Paralysis flag is clear");
            }
            else
            {
                UO.Print("Still paralyzed");
            }
        }
        else
        {
            UO.Print("Self is unavailable");
        }

        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 [GetFrozen].
• InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetLocked: bridge.GetLocked(serial).
• 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.

serial => bridge.GetLocked(serial)

Codice interno di implementazione; non è uno script autonomo.

() => getter(bridge.Self)

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

• InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddState.

Parametri: value (Any)

Risultato: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [GetFrozen].
• InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetLocked: bridge.GetLocked(serial).
• InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(value).

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.

serial => bridge.GetLocked(serial)

Codice interno di implementazione; non è uno script autonomo.

value => getter(GetObject(value))

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

• InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddState.

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

dynamic UO.GetGold();

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.GetGold();
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.GetGold();
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.GetGold();
    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.GetGold();
        await Delay(500);
        var after = UO.GetGold();
        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.ReadGoldValue.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Gold: bridge.Gold.

Codice interno di implementazione; non è uno script autonomo.

private InjectionValue ReadGoldValue()

        {

            // The existing bridge carries all 32 unsigned status-counter bits in

            // an Int32. Keep small results Integer; Double exactly represents

            // every UInt32 and avoids returning a negative large gold amount.

            uint amount = unchecked((uint)bridge.Gold);

            return amount <= int.MaxValue ? new InjectionValue((int)amount)

                : new InjectionValue((double)amount);

        }

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

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

Legge l'integrità attuale dal modello locale.

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

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.

int hp = UO.GetHP();
UO.Print($"HP = {hp}");

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.GetHP();
UO.Print("GetHP: " + 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.GetHP();
UO.Print("GetHP: " + 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.GetHP();
    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:

• 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.GetHP(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.GetHP.
• InjectionScript.Runtime.InjectionApiUO.GetHP: GetHP("self").

Codice interno di implementazione; non è uno script autonomo.

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

Parametri: id (Any/Integer/String)

Risultato: int / Any.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetHP: bridge.GetHP(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 "gethp": return new InjectionValue(bridge.GetHP(Arg(0, bridge.Self)));

Parametri: id (Any/Integer/String)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

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

Parametri: id (Any/Integer/String)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

public int GetHP(string id) => GetHP(GetObject(id));

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

int UO.GetHidden();
int UO.GetHidden(object? value);

Mette alla prova la furtività del personaggio.

• value — 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.GetHidden();
UO.Print("GetHidden: " + 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.GetHidden();
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.GetHidden(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.GetHidden();
        await Delay(500);
        var after = UO.GetHidden();
        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.RegisterCharacterGetterAliases [GetHidden].
• InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Hidden: bridge.Hidden(serial).
• 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.

serial => bridge.Hidden(serial)

Codice interno di implementazione; non è uno script autonomo.

() => getter(bridge.Self)

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

• InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddState.

Parametri: value (Any)

Risultato: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [GetHidden].
• InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Hidden: bridge.Hidden(serial).
• InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(value).

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.

serial => bridge.Hidden(serial)

Codice interno di implementazione; non è uno script autonomo.

value => getter(GetObject(value))

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

• InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddState.

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

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

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

• 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.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().
• 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.GetInt();
UO.Print("GetInt: " + 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.GetInt();
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.GetInt();
    await Delay(1000);
    var after = UO.GetInt();
    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.GetInt();
        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.GetInt(id);
    var byName = UO.GetInt("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 [GetInt].
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Intelligence: bridge.Intelligence.

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

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.GetIntelligence: bridge.GetIntelligence(Arg(0)).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Intelligence: bridge.Intelligence.

Codice interno di implementazione; non è uno script autonomo.

case "getint": return new InjectionValue(arguments.Length > 0 ? bridge.GetIntelligence(Arg(0)) : bridge.Intelligence);

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

int UO.GetIntelligence();

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.GetIntelligence();
UO.Print("GetIntelligence: " + 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.GetIntelligence();
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.GetIntelligence();
    await Delay(1000);
    var after = UO.GetIntelligence();
    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.GetIntelligence();
        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 [GetIntelligence].
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Intelligence: bridge.Intelligence.

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

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.GetLife();

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.GetLife();
UO.Print("GetLife: " + 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.GetLife();
UO.Print("GetLife: " + 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.GetLife();
    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.GetLife();
    }

    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 [GetLife].
• 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.GetLuck();

Legge il contatore dello stato del tuo personaggio: punti fortuna.

Non ci sono parametri.

int — punti fortuna, 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.Luck 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.
• Luck legge i punti fortuna del server memorizzati come UInt16 dallo stato type >= 4. Questa non è una percentuale, un numero casuale o una garanzia della qualità del bottino. Durante la lettura, il cliente non calcola il tasso di rilascio e non aggiunge bonus all'equipaggiamento.
• 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.GetLuck();
UO.Print("GetLuck: " + 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.GetLuck();
UO.Print("Luck: " + 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.GetLuck();
    await Delay(500);
    var after = UO.GetLuck();
    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:

• LuckAtLeast(minimo) riceve un requisito numerico; 1000 è un esempio, non un limite o una percentuale. Rifiuta l'assenza di un Giocatore, legge fortuna una volta e restituisce bool: true o false per valore >= minimo. La fortuna in sé non è bool. I punti memorizzati nella cache vengono confrontati e non vengono previsti i bottini.

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(LuckAtLeast(1000)) == true))
        {
            UO.Print("Local check passed");
        }
        else
        {
            UO.Print("Local check failed or data unavailable");
        }

        return null;
    }

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

        var value = UO.GetLuck();
        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 [GetLuck].
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Luck: bridge.Luck.

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

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.GetMana();
dynamic UO.GetMana(object? objID);

Legge il mana 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 Mana, 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.GetMana();
UO.Print("GetMana: " + 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.GetMana();
UO.Print("GetMana: " + 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.GetMana();
    if (Truth(value >= 10))
    {
        UO.Print("At least ten mana points are known");
    }

    return null;
}

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