Українська · Русский · 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.MaxStamina();

Legge la resistenza massima dal modello locale.

Non ci sono parametri.

int è il valore del campo StaminaMax, 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.MaxStamina();
UO.Print("MaxStamina: " + 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.MaxStamina();
UO.Print("MaxStamina: " + 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.MaxStamina();
    if (Truth(value > 0))
    {
        UO.Print("Stamina percent: " + Convert.ToString(UO.Stamina() * 100 / value));
    }

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

    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 [MaxStamina].
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.MaxStamina: bridge.MaxStamina.

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

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

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

Non ci sono parametri.

int — peso massimo 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.WeightMax 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.
• MaxWeight legge la cache WeightMax. Lo stato nativo type >= 5 imposta il limite del server su UInt16, anche se è uguale a 0. Il vecchio stato esteso lo calcola una volta alla ricezione: protocollo UO >= 5.0.0a - 7 * floor(Strength / 2) + 40; quello più vecchio è Strength * 4 + 25. Il risultato viene salvato come UInt16; i valori estremi vengono avvolti modulo 65536. Converti.ToString=101 dà rispettivamente 390 o 429. Quando si modifica Strength separatamente, il getter stesso non ricalcola il limite.
• 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.MaxWeight();
UO.Print("MaxWeight: " + 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.MaxWeight();
UO.Print("WeightMax: " + 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.MaxWeight();
    await Delay(500);
    var after = UO.MaxWeight();
    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.Weight();
        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.MaxWeight.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.MaxWeight: bridge.MaxWeight.

Codice interno di implementazione; non è uno script autonomo.

public int MaxWeight() => bridge.MaxWeight;

int UO.Mount();
int UO.Mount(object? mount);

Mount e Dismount inviano l’uso dell’oggetto senza doppio clic manuale o attacco in modalità guerra. int è il serial attuale dell’oggetto sul layer Mount, non un successo. La risposta server è asincrona: Mount può restituire ancora 0 e Dismount il serial prima della rimozione. Controllare poi ObjAtLayer("Mount").

• mount — Seriale cavalcatura; se omesso usa l’ultimo bersaglio.

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

#mount 0x00001234
#mount

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

int mountLayerSerial = UO.Mount(0x00001234);
UO.Print(UO.Int2Hex(mountLayerSerial));

int currentSerial = UO.Mount();
UO.Print(UO.Int2Hex(currentSerial));

UO.Mount(0x00001234);
for (int attempt = 0; attempt < 40; attempt++)
{
    var serial = UO.ObjAtLayer("Mount");
    if (Convert.ToString(serial) != "0" && Convert.ToString(serial) != "0x00000000")
    {
        UO.Print(Convert.ToString(serial));
        break;
    }
    await WaitAsync(50);
}

new CommandSample().Execute(UO);

sealed class CommandSample
{
    public void Execute(global::ClassicUO.CSharp.CSharpGameApi api)
    {
        int mountLayerSerial = api.Mount(0x00001234);
        api.Print(api.Int2Hex(mountLayerSerial));
    }
}

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

ClassicUOInjectionApiBridge -> NativeMountController.Request
  -> OutgoingPackets.Send_UseObjectRequest (0x06)
  -> MountedLayerSerialUnsafe -> Player.FindItemByLayer(Layer.Mount)

ClassicUO · ServUO BaseMount

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

dynamic UO.ObjAtLayer(object? layer);

Trova un oggetto nel livello specificato dell'equipaggiamento del tuo personaggio.

• layer — Un argomento obbligatorio: numero di livello 1..29 o un nome di stringa dall'elenco seguente. Il numero 0 e il nome Invalid danno 0. Le maiuscole e gli spazi finali del nome vengono ignorati. Un nome di stringa sconosciuto causa un errore di script; la stringa numerica "1" non sostituisce il numero 1.

Il formato numerico restituisce int - serial per l'elemento o 0 per un livello vuoto/non valido. La forma stringa restituisce string nella forma "0x40001001" se l'elemento viene trovato, altrimenti int 0. Questo è il ID dell'articolo, non il numero del livello, graphic/type o la quantità. Metadati object? il formato stringa riflette due possibili tipi di risultato.

• 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.
• I dati dell'apparecchiatura self vengono controllati. Il team non apre la borsa, non indossa l'oggetto né invia una richiesta di ispezione.
• I numeri esterni a 1..29 danno 0 senza conversione modulo 256; ad esempio, 257 non può selezionare la mano destra.
• Tutti i livelli numerici e i nomi di stringa supportati:
• 1 OneHanded/Rhand/RightHand; 2 TwoHanded/Lhand/LeftHand; 3 Shoes; 4 Pants; 5 Shirt; 6 Helmet/Hat; 7 Gloves; 8 Ring; 9 Talisman; 10 Necklace/Neck.
• 11 Hair; 12 Waist; 13 Torso; 14 Bracelet/Brace; 15 Face; 16 Beard; 17 Tunic; 18 Earrings/Ear; 19 Arms; 20 Cloak.
• 21 Backpack/Bpack/BackpackLayer; 22 Robe; 23 Skirt; 24 Legs; 25 Mount; 26 ShopBuyRestock/Rstk; 27 ShopBuy/NRstk; 28 ShopSell/Sell; 29 Bank.

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.

object? item = UO.ObjAtLayer("Rhand");
if (item is string serial) UO.Print("Equipped serial: " + serial);
else UO.Print("The layer is empty");

Parametri e flusso di esecuzione:

• La mano destra seleziona il livello 1. In caso di successo, la mano è una stringa esadecimale; se assente, il numero 0.
• Convert.ToString consente di visualizzare entrambi i tipi possibili. Il risultato non può essere preso come graphic dell'arma.

object? hand = UO.ObjAtLayer("Rhand");
if (hand is string serial)
{
    UO.Print("Right hand serial: " + serial);
}
else
{
    UO.Print("Right hand is empty 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:

• Il numero 2 seleziona TwoHanded. Questo modulo restituisce sempre int.
• Exists verifica che l'oggetto sia disponibile per la lettura delle sue proprietà. GetGraphic restituisce un type separato.

return  RunScenario();
 object? RunScenario()
{
    var item = UO.ObjAtLayer(2);
    if (Truth(UO.Exists(item)))
    {
        UO.Print("Two-handed layer serial: " + Convert.ToString(item));
        UO.Print("Graphic: " + UO.GetGraphic(item));
    }

    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:

• 21—strato Backpack; risultato 0 è possibile prima di caricare l'attrezzatura.
• 257 è fuori dall'elenco e dà sempre 0. Questa non è una designazione alternativa per lo strato 1.

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 bag = UO.ObjAtLayer(21);
        var invalid = UO.ObjAtLayer(257);
        UO.Print("Backpack serial: " + Convert.ToString(bag));
        UO.Print("Invalid layer: " + Convert.ToString(invalid));
        return null;
    }
}

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

Parametri: layer (Any/String)

Risultato: dynamic / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "objatlayer":

                    return new InjectionValue(arguments[0].Kind == InjectionValueKind.String

                        ? GetObject(ObjAtLayer(Text(0))) : bridge.ObjAtLayer(Arg(0)));

Parametri: layer (Any/String)

Risultato: dynamic / Any.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ObjAtLayer.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.ObjAtLayer: bridge.ObjAtLayer(ConvertLayer(layer)).
• InjectionScript.Runtime.InjectionApiUO.ConvertLayer: ConvertLayer(layer).

Codice interno di implementazione; non è uno script autonomo.

public InjectionValue ObjAtLayer(string layer)

        {

            var id = bridge.ObjAtLayer(ConvertLayer(layer));

            if (id == 0)

                return InjectionValue.Zero;



            return new InjectionValue("0x" + id.ToString("X8"));

        }

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

int UO.ObjAtLayerEx(object? layerType, object? playerID);

Legge un elemento/contenitore nel livello specificato per il carattere caricato specificato.

• layerType — Numero numerico del livello 1..29. Accetta un numero intero o una stringa numerica, come 26 o "0x1A". I nomi delle stringhe Rhand/ShopBuyRestock e le costanti del layer nudo non vengono convertiti in numeri qui. Usa un numero.
• playerID: carattere seriale/mobile, un numero, una stringa esadecimale o un nome di oggetto risolvibile, come "self"/"lasttarget". Il grafico/type dell'articolo o ID del contenitore stesso non sono adatti.

int: serial dell'oggetto/contenitore sul livello o 0 se il livello è vuoto/sconosciuto, il numero non è valido o non è caricato alcun cellulare. Questo non è bool o un numero di livello.

• La lettura è locale, senza target, acquisto, apertura di contenitore e richiesta di rete.
• L'intervallo 1..29 è controllato. La conversione di un parametro stringa inappropriato può causare un errore; Non è necessario passare un nome di livello arbitrario al posto di un numero.
• È disponibile un UO.ObjAtLayer separato per un carattere personalizzato con un nome di livello stringa. Non confondere il livello con world Z, l'indice statico o la coordinata gump.

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.ObjAtLayerEx(26, UO.GetSerial("lasttarget"));
UO.Print("ObjAtLayerEx: " + Convert.ToString(result));

Parametri e flusso di esecuzione:

• LayerType=26; ID giocatore=venditore; negozio — contenitore serial. Per GetContent viene passato il negozio, non il numero del livello.
• L'array è indicizzato da 0 alla lunghezza meno 1. Ogni elemento è serial. Un array vuoto significa che non ci sono elementi immediati caricati; l'acquisto non è stato portato a termine.

var vendor = UO.GetSerial("lasttarget");
if (Truth(vendor == "0x00000000"))
{
    UO.Print("Vendor not selected");
    return null;
}
var shop = UO.ObjAtLayerEx(26, vendor);
if (Truth(shop == 0))
{
    UO.Print("ShopBuyRestock container is not loaded");
    return null;
}
UO.Print("Shop container ID: " + Convert.ToString(shop));
var items = UO.GetContent(shop);
var i = 0;
while (Truth(i < ArrayLength(items)))
{
    var item = items[i];
    UO.Print(UO.GetName(item) + " | ID: " + Convert.ToString(item));
    UO.Print("Graphic: " + Convert.ToString(UO.GetType(item)));
    i = i + 1;
}
UO.Print("Loaded entries: " + Convert.ToString(ArrayLength(items)));

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

Parametri e flusso di esecuzione:

• wantedType è graphic e l'elemento è ID di un singolo articolo. stack conta record/stack; unità aggiunge il numero in essi contenuto.
• Si tratta della lettura della quantità già ricevuta, non del saldo garantito da un futuro acquisto. Non c'è nessun prezzo specificato qui.

return  RunScenario();
 object? RunScenario()
{
    var vendor = UO.GetSerial("lasttarget");
    if (Truth(vendor == "0x00000000"))
    {
        UO.Print("Vendor not selected");
        return null;
    }

    var shop = UO.ObjAtLayerEx(26, vendor);
    if (Truth(shop == 0))
    {
        UO.Print("Shop layer is not loaded");
        return null;
    }

    var wantedType = 0x1766;
    var stacks = 0;
    var units = 0;
    var items = UO.GetContent(shop);
    var i = 0;
    while (Truth(i < ArrayLength(items)))
    {
        var item = items[i];
        if (Truth(UO.GetType(item) == wantedType))
        {
            stacks = stacks + 1;
            units = units + UO.GetQuantity(item);
        }

        i = i + 1;
    }

    UO.Print("Stacks: " + Convert.ToString(stacks) + " | Units: " + Convert.ToString(units));
    return null;
}

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

Parametri e flusso di esecuzione:

• ShowVendorLayer è dichiarato nella sua interezza. fornitore - ID NPC, layerNumber - 26/27/28, didascalia - solo firma.
• I contenitori potrebbero essere sconosciuti al client. 0 viene controllato prima di GetContent: un GetContent(0) esplicito significherebbe chiedere oggetti a terra, cosa che qui non è richiesta.

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 vendor = UO.GetSerial("lasttarget");
        if (Truth(vendor == "0x00000000"))
        {
            UO.Print("Vendor not selected");
            return null;
        }

        ShowVendorLayer(vendor, 26, "ShopBuyRestock / Rstk");
        ShowVendorLayer(vendor, 27, "ShopBuy / NRstk");
        ShowVendorLayer(vendor, 28, "ShopSell / Sell");
        return null;
    }

    void ShowVendorLayer(dynamic vendor, dynamic layerNumber, dynamic caption)
    {
        var container = UO.ObjAtLayerEx(layerNumber, vendor);
        if (Truth(container == 0))
        {
            UO.Print(caption + ": not loaded");
            return;
        }

        var items = UO.GetContent(container);
        UO.Print(caption + " | Container ID: " + Convert.ToString(container));
        UO.Print("Loaded entries: " + Convert.ToString(ArrayLength(items)));
    }

    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: layerType (Any), playerID (Any)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "objatlayerex": return new InjectionValue(bridge.ObjAtLayerEx(Arg(0), Arg(1)));

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

int UO.Paralyzed();
int UO.Paralyzed(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.Paralyzed();
UO.Print("Paralyzed: " + 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.Paralyzed();
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.Paralyzed(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.Paralyzed()) == true) && Truth(attempts < 10))
        {
            await Delay(100);
            attempts = attempts + 1;
        }

        if (Truth(UO.IsNPC("self")))
        {
            if (Truth(Truth(UO.Paralyzed()) == 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.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetLocked: bridge.GetLocked(bridge.Self).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self: bridge.Self.

Codice interno di implementazione; non è uno script autonomo.

case "paralyzed": return new InjectionValue(bridge.GetLocked(bridge.Self));

Parametri: value (Any)

Risultato: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [Paralyzed].
• 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 · 繁體中文 · 日本語 · 한국어

int UO.PhysicalResist();

Legge il campo di resistenza del personaggio attuale: armatura/resistenza fisica.

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.PhysicalResistance 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.
• PhysicalResistance - campo armatura/stato del server: il server classico può trasmettere il valore dell'armatura e le regole con resistenze possono trasmettere resistenza fisica. API non converte dall'uno all'altro e non calcola la percentuale di riduzione del danno. Armor e gli alias fisici leggono lo stesso campo.
• 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.PhysicalResist();
UO.Print("PhysicalResist: " + 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.PhysicalResist();
UO.Print("PhysicalResistance: " + 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.PhysicalResist();
    await Delay(500);
    var after = UO.PhysicalResist();
    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.PhysicalResist();
        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 [PhysicalResist].
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Armor: bridge.Armor.

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

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 · 繁體中文 · 日本語 · 한국어

void UO.Poison();
void UO.Poison(object? target);

Utilizza l'abilità Avvelenamento, se necessario, su un determinato bersaglio.

• target - Opzionale serial/alias target. Nessun argomento - solo UseSkill("Avvelenamento"). Con argomento - UseSkillAtTarget("Avvelenamento", bersaglio).

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

• Il comando legacy registrato non è un getter per la resistenza all'avvelenamento o lo stato dell'avvelenamento. Il ramo evoca l'abilità e la scarta 1/0.
• In un modulo con un bersaglio, UseSkillAtTarget controlla un serial positivo, prepara il bersaglio prima di richiedere l'abilità; se l'abilità non viene accettata, annulla il bersaglio. L'avvelenamento del bersaglio da parte del server non è garantito.

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

Parametri e flusso di esecuzione:

• Utilizza l'abilità Avvelenamento, se necessario, su un determinato bersaglio.

UO.Poison();

Parametri e flusso di esecuzione:

• Il comando legacy registrato non è un getter per la resistenza all'avvelenamento o lo stato dell'avvelenamento. Il ramo evoca l'abilità e la scarta 1/0.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Exists("lasttarget")))
    {
        UO.Poison("lasttarget");
    }

    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:

• In un modulo con un bersaglio, UseSkillAtTarget controlla un serial positivo, prepara il bersaglio prima di richiedere l'abilità; se l'abilità non viene accettata, annulla il bersaglio. L'avvelenamento del bersaglio da parte del server non è garantito.

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.Poison(id);
            UO.Print(UO.Waiting());
        }

        return null;
    }

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

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

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
• InjectionScript.Runtime.InjectionApiUO.UseSkillAtTarget: UseSkillAtTarget(new InjectionValue("Poisoning"), arguments[0]).
• InjectionScript.Runtime.InjectionApiUO.UseSkill: UseSkill("Poisoning").

Codice interno di implementazione; non è uno script autonomo.

case "poison":

                    if (arguments.Length > 0) UseSkillAtTarget(new InjectionValue("Poisoning"), arguments[0]);

                    else UseSkill("Poisoning");

                    break;

Parametri: target (Any)

Risultato: void / Unit.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
• InjectionScript.Runtime.InjectionApiUO.UseSkillAtTarget: UseSkillAtTarget(new InjectionValue("Poisoning"), arguments[0]).
• InjectionScript.Runtime.InjectionApiUO.UseSkill: UseSkill("Poisoning").

Codice interno di implementazione; non è uno script autonomo.

case "poison":

                    if (arguments.Length > 0) UseSkillAtTarget(new InjectionValue("Poisoning"), arguments[0]);

                    else UseSkill("Poisoning");

                    break;

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

int UO.PoisonResist();

Legge il campo di resistenza del personaggio attuale: veleno.

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.PoisonResistance 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.PoisonResist();
UO.Print("PoisonResist: " + 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.PoisonResist();
UO.Print("PoisonResistance: " + 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.PoisonResist();
    await Delay(500);
    var after = UO.PoisonResist();
    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.PoisonResist();
        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.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.PoisonResistance: bridge.PoisonResistance.

Codice interno di implementazione; non è uno script autonomo.

case "poisonresist": return new InjectionValue(bridge.PoisonResistance);

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

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

Controlla l'avvelenamento 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 IsPoisoned, 0 non ha flag o mobile manca. Il grado di veleno e il tempo rimanente non vengono restituiti.

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.
• Per Poisoned/Flying viene presa in considerazione la versione del protocollo: fino a 7.0.0.0 il bit 0x04 significa veleno; iniziando con 7.0.0.0 significa fuga e il veleno viene immagazzinato separatamente. Il volo non viene calcolato da Z.

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.Poisoned();
UO.Print("Poisoned: " + 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.Poisoned();
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.Poisoned(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.Poisoned();
        await Delay(500);
        var after = UO.Poisoned();
        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.Poisoned.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Poisoned: bridge.Poisoned(bridge.Self).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self: bridge.Self.

Codice interno di implementazione; non è uno script autonomo.

public int Poisoned() => bridge.Poisoned(bridge.Self);

Parametri: id (Any)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

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

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

dynamic UO.Race();

Legge la razza del personaggio dal modello client.

Non ci sono parametri.

int — 1=umano, 2=elfo, 3=gargoyle secondo il modello del client. 0 significa nessun carattere caricato. Non è body/graphic e non serial.

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

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

Parametri e flusso di esecuzione:

• La chiamata senza argomenti si riferisce a self. La razza del personaggio viene memorizzata come valore.
• Convert.ToString converte il numero da emettere e non cambia il significato del risultato.

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

Parametri e flusso di esecuzione:

• Il valore viene letto una volta senza argomenti. La razza del personaggio viene utilizzata 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.Race();
    if (Truth(value == 3))
    {
        UO.Print("Player race is gargoyle");
    }

    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.
• Cambiamento rispetto: razza del personaggio. 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.Race();
        await Delay(1000);
        var after = UO.Race();
        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: dynamic / Any.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Race: bridge.Race.

Codice interno di implementazione; non è uno script autonomo.

case "race": return new InjectionValue(bridge.Race);

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

void UO.RemoveEarrings();

Richiede la rimozione di un elemento dal livello Ear.

Non ci sono parametri.

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

• ExecuteLegacyManualAlias chiama Unequip("Ear"). ConvertLayer seleziona il livello numerico, bridge.Unequip richiede il trasferimento nello zaino.
• Il risultato dell'Unequip interno (1/0) del comando legacy viene scartato; chiamare su una linea separata. In mancanza dell'oggetto/zaino la richiesta potrebbe non essere eseguita. Il controllo ObjAtLayer dopo la chiamata legge solo lo stato locale.

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

Parametri e flusso di esecuzione:

• Richiede la rimozione di un elemento dal livello Ear.

UO.RemoveEarrings();

Parametri e flusso di esecuzione:

• ExecuteLegacyManualAlias chiama Unequip("Ear"). ConvertLayer seleziona il livello numerico, bridge.Unequip richiede il trasferimento nello zaino.

return  RunScenario();
 object? RunScenario()
{
    UO.Print(UO.ObjAtLayer("Ear"));
    UO.RemoveEarrings();
    return null;
}

Parametri e flusso di esecuzione:

• Il risultato dell'Unequip interno (1/0) del comando legacy viene scartato; chiamare su una linea separata. In mancanza dell'oggetto/zaino la richiesta potrebbe non essere eseguita. Il controllo ObjAtLayer dopo la chiamata legge solo lo stato locale.

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

     public object? RunScenario()
    {
        UO.RemoveEarrings();
        UO.Wait(500);
        UO.Print(UO.ObjAtLayer("Ear"));
        return null;
    }
}

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

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
• InjectionScript.Runtime.InjectionApiUO.Unequip: Unequip("Ear").

Codice interno di implementazione; non è uno script autonomo.

case "removeearrings": Unequip("Ear"); break;

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

void UO.RemoveHat();

Richiede la rimozione di un elemento dal livello Hat.

Non ci sono parametri.

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

• ExecuteLegacyManualAlias chiama Unequip("Hat"). ConvertLayer seleziona il livello numerico, bridge.Unequip richiede il trasferimento nello zaino.
• Il risultato dell'Unequip interno (1/0) del comando legacy viene scartato; chiamare su una linea separata. In mancanza dell'oggetto/zaino la richiesta potrebbe non essere eseguita. Il controllo ObjAtLayer dopo la chiamata legge solo lo stato locale.

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

Parametri e flusso di esecuzione:

• Richiede la rimozione di un elemento dal livello Hat.

UO.RemoveHat();

Parametri e flusso di esecuzione:

• ExecuteLegacyManualAlias chiama Unequip("Hat"). ConvertLayer seleziona il livello numerico, bridge.Unequip richiede il trasferimento nello zaino.

return  RunScenario();
 object? RunScenario()
{
    UO.Print(UO.ObjAtLayer("Hat"));
    UO.RemoveHat();
    return null;
}

Parametri e flusso di esecuzione:

• Il risultato dell'Unequip interno (1/0) del comando legacy viene scartato; chiamare su una linea separata. In mancanza dell'oggetto/zaino la richiesta potrebbe non essere eseguita. Il controllo ObjAtLayer dopo la chiamata legge solo lo stato locale.

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

     public object? RunScenario()
    {
        UO.RemoveHat();
        UO.Wait(500);
        UO.Print(UO.ObjAtLayer("Hat"));
        return null;
    }
}

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

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
• InjectionScript.Runtime.InjectionApiUO.Unequip: Unequip("Hat").

Codice interno di implementazione; non è uno script autonomo.

case "removehat": Unequip("Hat"); break;

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

void UO.RemoveNeckless();

Richiede la rimozione di un elemento dal livello Collo.

Non ci sono parametri.

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

• ExecuteLegacyManualAlias chiama Unequip("Neck"). ConvertLayer seleziona il livello numerico, bridge.Unequip richiede il trasferimento nello zaino.
• Il risultato dell'Unequip interno (1/0) del comando legacy viene scartato; chiamare su una linea separata. In mancanza dell'oggetto/zaino la richiesta potrebbe non essere eseguita. Il controllo ObjAtLayer dopo la chiamata legge solo lo stato locale.

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

Parametri e flusso di esecuzione:

• Richiede la rimozione di un elemento dal livello Collo.

UO.RemoveNeckless();

Parametri e flusso di esecuzione:

• ExecuteLegacyManualAlias chiama Unequip("Neck"). ConvertLayer seleziona il livello numerico, bridge.Unequip richiede il trasferimento nello zaino.

return  RunScenario();
 object? RunScenario()
{
    UO.Print(UO.ObjAtLayer("Neck"));
    UO.RemoveNeckless();
    return null;
}

Parametri e flusso di esecuzione:

• Il risultato dell'Unequip interno (1/0) del comando legacy viene scartato; chiamare su una linea separata. In mancanza dell'oggetto/zaino la richiesta potrebbe non essere eseguita. Il controllo ObjAtLayer dopo la chiamata legge solo lo stato locale.

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

     public object? RunScenario()
    {
        UO.RemoveNeckless();
        UO.Wait(500);
        UO.Print(UO.ObjAtLayer("Neck"));
        return null;
    }
}

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