IT UO Topic character

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

Carattere

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

Lo stato del tuo personaggio, caratteristiche, resistenze ed equipaggiamento. Per un'entità specifica, utilizzare un sovraccarico con serial se è nella scheda comando.

Sezioni

Argomento	Comandi e spiegazioni
Identity	UO.Self · UO.GetSerial · UO.GetName · UO.GetTitle · UO.GetSex · UO.GetRace
Stats	UO.HP · UO.MaxHP · UO.Mana · UO.MaxMana · UO.Stamina · UO.MaxStamina · UO.Str · UO.Dex · UO.Int · UO.Weight · UO.MaxWeight · UO.Luck · UO.GetStatLockState · UO.SetStatLockState
Status	UO.Alive · UO.Dead · UO.Hidden · UO.Poisoned · UO.Frozen · UO.Paralyzed · UO.Flying · UO.WarMode · UO.IsYellowHits
Resists	UO.PhysicalResist · UO.GetPhysicalResist · UO.ResistPhysical · UO.GetResistPhysical · UO.FireResist · UO.GetFireResist · UO.ResistFire · UO.GetResistFire · UO.ColdResist · UO.GetColdResist · UO.ResistCold · UO.GetResistCold · UO.PoisonResist · UO.GetPoisonResist · UO.ResistPoison · UO.GetResistPoison · UO.EnergyResist · UO.GetEnergyResist · UO.ResistEnergy · UO.GetResistEnergy · UO.GetResist
Livelli di caratteri	UO.ObjAtLayer · UO.ObjAtLayerEx · UO.GetLayer · UO.GetEquipment
Equipment	UO.GetEquipment · UO.EquipItems · UO.UnequipItems · UO.WearItem
Dress / Undress	UO.SetDress · UO.Dress · UO.Undress · UO.DressSavedSet
Arm / Disarm	UO.SetArm · UO.Arm · UO.Disarm
Mount / Dismount	UO.Mount · UO.Dismount
Paperdoll	UO.UseSelfPaperdollScroll · UO.UseOtherPaperdollScroll

Tutti i comandi del tema

Livelli di caratteri

Tutti i livelli: scopo, significati ed esempi. Il numero del livello, serial dell'oggetto equipaggiato e il suo graphic hanno valori diversi.

Esempi sull'argomento

Ogni carta comando ha diversi scenari indipendenti: codice diretto, funzioni e classi. Di seguito sono selezionati brevi scenari; restrizioni e un'analisi completa sono nelle carte.

UO.HP

Parametri, risultato e tutti gli scenari

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

UO.ObjAtLayer

Parametri, risultato e tutti gli scenari

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;

Parti del riferimento

1 · 2 · 3 · 4 · 5

Riferimento completo dei comandi

UO.Alive

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

Firme C#

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

Verifica la presenza di un oggetto senza segno di morte.

Parametri

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.

Valore restituito

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 - il positivo serial esiste e non è contrassegnato come morto. Il famoso elemento fornisce anche 1: questo non è il filtro mobile. Un oggetto morto/mancante dà 0.

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.

Comportamento

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.

Script C# autonomi

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.

Esempio semplice

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

1. Controlla il tuo stato - script diretto

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

2. Oggetto selezionato e funzione completa ReadState - funzione script

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

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

3. Notare un cambiamento in mezzo secondo: classe di script

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.Alive();
        await Delay(500);
        var after = UO.Alive();
        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;
}

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

`UO.Alive()` — `UO.Alive()`

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [Alive].
InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Exists: bridge.Exists(serial).
InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::IsDeadState: IsDeadState(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 => serial > 0 && bridge.Exists(serial) != 0 && IsDeadState(serial) == 0 ? 1 : 0

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.

`UO.Alive(value)` — `UO.Alive(Any)`

Parametri: value (Any)

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [Alive].
InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Exists: bridge.Exists(serial).
InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::IsDeadState: IsDeadState(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 => serial > 0 && bridge.Exists(serial) != 0 && IsDeadState(serial) == 0 ? 1 : 0

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.

UO.Arm

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

Firme C#

void UO.Arm(object? name);

Ripristina un set di armi e scudi con nome precedentemente salvato.

Parametri

name — Nome della stringa del set, ad esempio "viaggio" o "battaglia". I nomi non fanno distinzione tra maiuscole e minuscole. L'abbigliamento e i set di armi sono tenuti separatamente: in entrambi è consentito lo stesso nome. Questa non è una cosa ID o un nome file. Solo SetDress consente l'assenza di un nome: quindi viene registrato un set separato per DressSavedSet/EquipDressSet.

Valore restituito

void - nessun valore. Chiama su una linea separata; non assegnare il risultato né confrontarlo con true. Il salvataggio e l'eliminazione modificano la voce, non l'attrezzatura.

Comportamento

Abbigliamento: strati 3,4,5,6,7,8,10,12,13,14,17,18,19,20,22,23,24. Armi: solo 1 e 2. Capelli, barba, zaino, animale e banca non sono inclusi in questi set.
Le cose specifiche serial già caricate vengono registrate nei propri livelli. Salvando nuovamente lo stesso nome si sostituisce la voce. Anche gli strati vuoti hanno senso: una volta ripristinati, il corrispondente strato occupato verrà rilasciato nel proprio zaino. Pertanto, un set completamente vuoto salvato rimuove gli elementi dai suoi livelli.
Il set viene archiviato nello stato di runtime. La chiamata stessa non crea un file e non garantisce che il set verrà trasferito su un altro profilo o su un nuovo runtime. Innanzitutto, salva il set desiderato nel suo stato utilizzato. Il caricamento/salvataggio dello stato generale del client è un meccanismo separato.
Una corrispondenza esatta tra il ID corrente e quello salvato viene saltata, senza essere utilizzata/rilanciata nuovamente. Un elemento mancante non viene sostituito da un type simile. Il fallimento di un'operazione non cancella quelle riuscite e non interferisce con i tentativi delle altre; Non esiste un rollback automatico. Hai bisogno di connessione e materiale caricato. Quando rimosso, viene utilizzato un vero zaino.
UO.Set("equipfordress", 0) seleziona la richiesta di utilizzo dell'oggetto (modalità iniziale); valore diverso da zero: raccogli/equipaggia. Lo strato indossabile desiderato viene controllato in entrambe le modalità. Un capo già indossato non può essere cambiato con l'uso ripetuto. DressSpeed è valido dopo la richiesta accettata, il ritiro rispetta inoltre DropDelay.
Dress e Arm restituiscono void anche in caso di guasto. Il messaggio che le richieste sono state accettate non significa conferma da parte del server. Per la continuazione dipendente dall'indossamento, controllare gli strati effettivi con aspettative limitate.
UO.SetDress · UO.Dress · UO.DressSavedSet · UO.SetArm · UO.Arm · UO.DressSpeed

Script C# autonomi

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.

Esempio semplice

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

1. Uso diretto - script diretto

Parametri e flusso di esecuzione:

Il set richiesto deve essere salvato in precedenza nello stesso stato di runtime. Non chiamare SetDress/SetArm subito prima di ogni ripristino: questo sovrascriverà la destinazione con gli elementi correnti.

UO.Arm("battle");

2. Nomi e modalità query - Funzione script

Parametri e flusso di esecuzione:

Un equipfordress diverso da zero seleziona raccolta/equipaggiamento; 350 — millisecondi DressSpeed. Queste impostazioni rimangono in fase di esecuzione dopo l'esempio. La rimozione e l'indossamento vengono decisi dal server.

return  RunScenario();
 object? RunScenario()
{
    UO.Set("equipfordress", 1);
    UO.DressSpeed(350);
    UO.Arm("battle");
    return null;
}

3. Script di supporto completo: classe di script

Parametri e flusso di esecuzione:

lasttarget — ID cose che dovrebbero essere incluse in un set precedentemente salvato. Lo strato di controllo 3 significa scarpe, 1 significa mano destra. AwaitSlot effettua controlli fino a 20 con una pausa di 100 ms e non ripete il comando. Ciò conferma solo l'elemento selezionato, non l'intero set.

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 expected = Asc(UO.GetSerial("lasttarget"), 0);
        if (Truth(expected == 0))
        {
            return 0;
        }

        UO.Arm("battle");
        return AwaitSlot(1, expected);
        return null;
    }

    dynamic AwaitSlot(dynamic layer, dynamic expected)
    {
        for (int attempt = (int)(1); attempt <= 20; attempt += (int)(1))
        {
            if (Truth(UO.ObjAtLayerEx(layer, UO.Self()) == expected))
            {
                return 1;
            }

            UO.Wait(100);
        }

        return 0;
    }

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

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

`UO.Arm(name)` — `UO.Arm(String)`

Parametri: name (String)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Arm.
InjectionScript.Runtime.InjectionApiUO.Equip: Equip(name, armSets, weaponLayers, "Weapon set requests processed.", "No weapons set with setarm.").

Codice interno di implementazione; non è uno script autonomo.

public void Arm(string name)

            => Equip(name, armSets, weaponLayers, "Weapon set requests processed.", "No weapons set with setarm.");

UO.Armor

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

Firme C#

int UO.Armor();

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

Parametri

Non ci sono parametri.

Valore restituito

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.

Comportamento

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.

Script C# autonomi

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.

Esempio semplice

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

1. Stampa valore salvato - script diretto

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.Armor();
UO.Print("PhysicalResistance: " + Convert.ToString(value));

2. Confronta due immagini: funzione script

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.Armor();
    await Delay(500);
    var after = UO.Armor();
    var difference = after - before;
    UO.Print("Resistance change: " + Convert.ToString(difference));
    return null;
}

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

3. Funzione completa di test della resistenza minima - Classe di script

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

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

`UO.Armor()` — `UO.Armor()`

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "armor": return new InjectionValue(bridge.Armor);

UO.CharName

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

Firme C#

dynamic UO.CharName();

Legge il nome del personaggio.

Parametri

Non ci sono parametri.

Valore restituito

string è un nome noto al cliente. Una stringa vuota indica un valore vuoto/sconosciuto o nessun oggetto. Questo non è serial o un percorso del profilo. Il nome/titolo del gioco non è tradotto dalla lingua IDE.

Comportamento

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.

Script C# autonomi

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.

Esempio semplice

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

1. Mostra testo dopo il login - script diretto

Parametri e flusso di esecuzione:

Non ci sono parametri: viene letto self.
La stringa vuota viene gestita in modo esplicito; questo non è il testo "0".

var text = UO.CharName();
if (Truth(text != ""))
{
    UO.Print(text);
}
else
{
    UO.Print("Text is unavailable");
}

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

2. Aggiungi testo al messaggio di registro - funzione script

Parametri e flusso di esecuzione:

Il tuo carattere viene letto, il valore viene memorizzato come una linea.
L'operatore + unisce le stringhe; Convert.ToString non è necessario per questo risultato.

return  RunScenario();
 object? RunScenario()
{
    var text = UO.CharName();
    UO.Print("Player имя: " + text);
    return null;
}

3. Confronta due istantanee: classe scenario

Parametri e flusso di esecuzione:

Entrambi i bandi si riferiscono a self; UO.Wait imposta la pausa 1000 ms.
La differenza potrebbe significare aggiornare i dati o lasciare il mondo. L'esempio non modifica il nome o il titolo.

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 previous = UO.CharName();
        await Delay(1000);
        var current = UO.CharName();
        if (Truth(previous != current))
        {
            UO.Print("Updated text: " + current);
        }

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

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

`UO.CharName()` — `UO.CharName()`

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetName: bridge.GetName(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 "getname":

                case "charname": return new InjectionValue(bridge.GetName(Arg(0, bridge.Self)));

UO.CharTitle

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

Firme C#

dynamic UO.CharTitle();

Legge il titolo del personaggio.

Parametri

Non ci sono parametri.

Valore restituito

string è un titolo noto al cliente. Una stringa vuota indica un valore vuoto/sconosciuto o nessun oggetto. Questo non è serial o un percorso del profilo. Il nome/titolo del gioco non è tradotto dalla lingua IDE.

Comportamento

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.

Script C# autonomi

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.

Esempio semplice

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

1. Mostra testo dopo il login - script diretto

Parametri e flusso di esecuzione:

Non ci sono parametri: viene letto self.
La stringa vuota viene gestita in modo esplicito; questo non è il testo "0".

var text = UO.CharTitle();
if (Truth(text != ""))
{
    UO.Print(text);
}
else
{
    UO.Print("Text is unavailable");
}

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

2. Aggiungi testo al messaggio di registro - funzione script

Parametri e flusso di esecuzione:

Il tuo carattere viene letto, il valore viene memorizzato come una linea.
L'operatore + unisce le stringhe; Convert.ToString non è necessario per questo risultato.

return  RunScenario();
 object? RunScenario()
{
    var text = UO.CharTitle();
    UO.Print("Player титул: " + text);
    return null;
}

3. Confronta due istantanee: classe scenario

Parametri e flusso di esecuzione:

Entrambi i bandi si riferiscono a self; UO.Wait imposta la pausa 1000 ms.
La differenza potrebbe significare aggiornare i dati o lasciare il mondo. L'esempio non modifica il nome o il titolo.

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 previous = UO.CharTitle();
        await Delay(1000);
        var current = UO.CharTitle();
        if (Truth(previous != current))
        {
            UO.Print("Updated text: " + current);
        }

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

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

`UO.CharTitle()` — `UO.CharTitle()`

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CharacterTitle: bridge.CharacterTitle.

Codice interno di implementazione; non è uno script autonomo.

case "chartitle": return new InjectionValue(bridge.CharacterTitle);

UO.CharacterTitle

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

Firme C#

string UO.CharacterTitle();

Legge il titolo del personaggio.

Parametri

Non ci sono parametri.

Valore restituito

string è un titolo noto al cliente. Una stringa vuota indica un valore vuoto/sconosciuto o nessun oggetto. Questo non è serial o un percorso del profilo. Il nome/titolo del gioco non è tradotto dalla lingua IDE.

Comportamento

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.

Script C# autonomi

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.

Esempio semplice

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

1. Mostra testo dopo il login - script diretto

Parametri e flusso di esecuzione:

Non ci sono parametri: viene letto self.
La stringa vuota viene gestita in modo esplicito; questo non è il testo "0".

var text = UO.CharacterTitle();
if (Truth(text != ""))
{
    UO.Print(text);
}
else
{
    UO.Print("Text is unavailable");
}

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

2. Aggiungi testo al messaggio di registro - funzione script

Parametri e flusso di esecuzione:

Il tuo carattere viene letto, il valore viene memorizzato come una linea.
L'operatore + unisce le stringhe; Convert.ToString non è necessario per questo risultato.

return  RunScenario();
 object? RunScenario()
{
    var text = UO.CharacterTitle();
    UO.Print("Player титул: " + text);
    return null;
}

3. Confronta due istantanee: classe scenario

Parametri e flusso di esecuzione:

Entrambi i bandi si riferiscono a self; UO.Wait imposta la pausa 1000 ms.
La differenza potrebbe significare aggiornare i dati o lasciare il mondo. L'esempio non modifica il nome o il titolo.

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 previous = UO.CharacterTitle();
        await Delay(1000);
        var current = UO.CharacterTitle();
        if (Truth(previous != current))
        {
            UO.Print("Updated text: " + current);
        }

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

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

`UO.CharacterTitle()` — `UO.CharacterTitle()`

Parametri: Nessun parametro.

Risultato: string / String.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [CharacterTitle].
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CharacterTitle: bridge.CharacterTitle.

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

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

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddText.

UO.ColdResist

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

Firme C#

int UO.ColdResist();

Legge il campo di resistenza del personaggio attuale: freddo.

Parametri

Non ci sono parametri.

Valore restituito

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.

Comportamento

Il comando non accetta argomenti. Usa le firme esatte sopra.
La lettura nel thread del gioco richiede Player.ColdResistance 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.

Script C# autonomi

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.

Esempio semplice

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

1. Stampa valore salvato - script diretto

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.ColdResist();
UO.Print("ColdResistance: " + Convert.ToString(value));

2. Confronta due immagini: funzione script

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.ColdResist();
    await Delay(500);
    var after = UO.ColdResist();
    var difference = after - before;
    UO.Print("Resistance change: " + Convert.ToString(difference));
    return null;
}

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

3. Funzione completa di test della resistenza minima - Classe di script

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

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

`UO.ColdResist()` — `UO.ColdResist()`

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.ColdResistance: bridge.ColdResistance.

Codice interno di implementazione; non è uno script autonomo.

case "coldresist": return new InjectionValue(bridge.ColdResistance);

UO.Dead

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

Firme C#

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

Controlla la morte del personaggio.

Parametri

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.

Valore restituito

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 IsDead, 0 non ha segno o mobile è assente. HP=0 di per sé non significa morte.

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.

Comportamento

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.

Script C# autonomi

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.

Esempio semplice

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

1. Controlla il tuo stato - script diretto

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

2. Oggetto selezionato e funzione completa ReadState - funzione script

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

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

3. Notare un cambiamento in mezzo secondo: classe di script

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.Dead();
        await Delay(500);
        var after = UO.Dead();
        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;
}

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

`UO.Dead()` — `UO.Dead()`

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Dead.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Dead: bridge.Dead().

Codice interno di implementazione; non è uno script autonomo.

public int Dead() => bridge.Dead();

`UO.Dead(id)` — `UO.Dead(Any)`

Parametri: id (Any)

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Dead.
InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(id).
InjectionScript.Runtime.InjectionApiUO.Dead: Dead().
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.IsDead: bridge.IsDead(serial).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self: bridge.Self.

Codice interno di implementazione; non è uno script autonomo.

public int Dead(InjectionValue id)

        {

            int serial = GetObject(id);

            if (serial == bridge.Self)

                return Dead();

            return serial > 0 ? bridge.IsDead(serial) : 0;

        }

UO.Dex

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

Firme C#

int UO.Dex();

Legge l'agilità attuale (Dexterity, DEX) del personaggio.

Parametri

Non ci sono parametri.

Valore restituito

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.

Comportamento

Il comando non accetta argomenti. Usa le firme esatte sopra.
Legge Player.Dexterity 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.Dex(), UO.Dexterity(), UO.GetDex(), UO.GetDexterity().

Script C# autonomi

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.

Esempio semplice

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

1. Leggere e visualizzare punti - script diretto

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.Dex();
UO.Print("Dexterity: " + Convert.ToString(value));

2. Confronta due immagini: funzione script

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.Dex();
    await Delay(1000);
    var after = UO.Dex();
    var change = after - before;
    UO.Print("Change: " + Convert.ToString(change));
    return null;
}

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

3. Funzione di convalida dei requisiti completa - Classe di script

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

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

`UO.Dex()` — `UO.Dex()`

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Dexterity: bridge.Dexterity.

Codice interno di implementazione; non è uno script autonomo.

case "dex": return new InjectionValue(bridge.Dexterity);

UO.Dexterity

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

Firme C#

int UO.Dexterity();

Legge l'agilità attuale (Dexterity, DEX) del personaggio.

Parametri

Non ci sono parametri.

Valore restituito

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.

Comportamento

Il comando non accetta argomenti. Usa le firme esatte sopra.
Legge Player.Dexterity 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.Dex(), UO.Dexterity(), UO.GetDex(), UO.GetDexterity().

Script C# autonomi

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.

Esempio semplice

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

1. Leggere e visualizzare punti - script diretto

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

2. Confronta due immagini: funzione script

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.Dexterity();
    await Delay(1000);
    var after = UO.Dexterity();
    var change = after - before;
    UO.Print("Change: " + Convert.ToString(change));
    return null;
}

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

3. Funzione di convalida dei requisiti completa - Classe di script

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

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

`UO.Dexterity()` — `UO.Dexterity()`

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

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

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

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddInteger.

UO.Disarm

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

Firme C#

int UO.Disarm();

Rimuove armi e scudi dalle mani: livelli 1 e 2. Non influisce sugli indumenti.

Parametri

Non ci sono parametri.

Valore restituito

Flag numerico int: 1 (condizione soddisfatta) - operazione locale accettata, 0 (condizione non soddisfatta) - rifiuto. Questa non è una conferma del server, né ID, né una quantità. Il server potrebbe fallire in seguito; controllare l'attrezzatura effettiva dopo aver risposto.

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.

Comportamento

Sono necessari elementi caricati e trascinamento a mano libera. Una volta rimosso, è necessario lo zaino vero e proprio self: il GrabBag di riserva non viene utilizzato. Gli articoli sconosciuti, distrutti e non idonei vengono rifiutati. Gli oggetti di altre persone non possono essere rimossi tramite UnequipItems. Un insieme non è una transazione atomica.
EquipItems/UnequipItems applica DressSpeed dopo l'operazione accettata prima dell'elemento successivo; Disarm/Undress - dopo ogni livello occupato. Il ritiro rispetta inoltre DropDelay quando il trasporto viene accettato. Le stesse impostazioni degli altri runtime non cambiano; l'accelerazione non prevale sulle limitazioni del server.
Un modulo di chiamata errato, un nome di livello sconosciuto o un valore non convertibile in un numero possono causare un errore di script anziché 0. L'istantanea dell'attrezzatura contiene solo i dati che sono già stati caricati. Nell'assistente, ChangeAndConfirm layer=1 è la mano destra: per altro, passa il suo layer reale.
Per un array, 1 significa che tutte le operazioni elencate sono accettate; in caso di eventuale rifiuto viene restituito 0. Gli elementi rimanenti vengono ancora elaborati, non è previsto alcun rollback. Un array vuoto produce 1 senza alcuna azione. Disarm/Undress dà 1 anche quando i layer richiesti sono già vuoti; il fallimento parziale dà 0.
UO.EquipItems · UO.UnequipItems · UO.DressSpeed · UO.DropDelay · UO.ObjAtLayerEx

Script C# autonomi

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.

Esempio semplice

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

1. Disarm - Un elemento o livello selezionato - script diretto

Parametri e flusso di esecuzione:

Per prima cosa, seleziona l'oggetto appropriato nel gioco: lasttarget - è ID. Nell'esempio Equip/WearItem, il livello 1 richiede un'arma secondaria. Unequip(1) rimuove la mano destra; Disarm/Undress funzionano con i propri livelli fissi. Non ci sono replay automatici dopo un rifiuto.

return UO.Disarm();

2. Disarm - Due elementi e salvato ID - funzione script

Parametri e flusso di esecuzione:

Per equipaggiarlo, 0x0F5E è un esempio di spada, 0x1B76 è un esempio di scudo. FindType li cerca tra gli oggetti caricati nello zaino, ASC converte l'esadecimale restituito-ID. Per la rimozione vengono letti i propri livelli attuali. Se l'elemento richiesto non è disponibile, lo script termina. L'array memorizza due ID; Ogni elemento viene trasferito interamente.

return  RunScenario();
 object? RunScenario()
{
    var first = UO.ObjAtLayerEx(1, UO.Self());
    var second = UO.ObjAtLayerEx(2, UO.Self());
    if (Truth(first == 0) || Truth(second == 0))
    {
        return 0;
    }

    UO.AddObject("saved_first", first);
    UO.AddObject("saved_second", second);
    return UO.Disarm();
    return null;
}

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

3. Disarm - Funzione completa con attesa limitata - classe script

Parametri e flusso di esecuzione:

ChangeAndConfirm esegue il comando una volta. Quindi controlla lo stato attuale fino a 20 volte con una pausa di 100 ms. 1 - il controllo ha rilevato lo stato previsto, 0 - errore o attesa scaduta. Questo è il risultato del nostro helper, non un nuovo comando integrato. Anche richiamare l'operazione stessa potrebbe richiedere del tempo.

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

     public object? RunScenario()
    {
        return ChangeAndConfirm();
        return null;
    }

    dynamic ChangeAndConfirm()
    {
        if (!(Truth(UO.Disarm())))
        {
            return 0;
        }

        dynamic[] layers = new dynamic[checked((int)(1) + 1)];
        layers[0] = 1;
        layers[1] = 2;
        for (int attempt = (int)(1); attempt <= 20; attempt += (int)(1))
        {
            dynamic empty = true;
            for (int i = (int)(0); i <= ArrayLength(layers) - 1; i += (int)(1))
            {
                if (Truth(UO.ObjAtLayerEx(layers[i], UO.Self()) != 0))
                {
                    empty = false;
                }
            }

            if (Truth(empty))
            {
                return 1;
            }

            UO.Wait(100);
        }

        return 0;
    }

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

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

`UO.Disarm()` — `UO.Disarm()`

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Disarm.
InjectionScript.Runtime.InjectionApiUO.Unequip: Unequip(weaponLayers, "Weapons disarmed.").

Codice interno di implementazione; non è uno script autonomo.

public int Disarm()

            => Unequip(weaponLayers, "Weapons disarmed.");

UO.Dismount

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

Firme C#

void UO.Dismount();

Richiede lo smontaggio se il personaggio è attualmente montato.

Parametri

Non ci sono parametri.

Valore restituito

void - nessun valore restituito. Chiama come una linea separata, non confrontare il risultato con 1/true. Controlla il livello 25 dopo che il server ha risposto.

Comportamento

Il comando invia una richiesta per utilizzare l'oggetto protocollo UO (0x06), senza emulazione del mouse. Ignora il comune gestore double-click dell'interfaccia: in modalità guerra, la richiesta non viene sostituita da un attacco.
Lo stato della montatura viene letto dal layer 25. Cambia dopo i dati del server; il rientro dal comando non conferma il completamento dell'atterraggio/discesa.
Le richieste ripetute di montaggio/smontaggio vengono temporaneamente unite: nessuna nuova richiesta viene inviata finché non sono trascorsi un cambio di livello, un cambio di carattere o 5 secondi. Ciò protegge dalla duplicazione tra gli script.
Se il personaggio è assente, fuori gioco o per un personaggio morto, la richiesta non viene inviata. Le regole finali per proprietà, disponibilità e posti a sedere sono determinate dal server.
Se il livello 25 è vuoto, non viene visualizzato alcun messaggio e paperdoll non si apre. Una barca di servizio con graphic 0x3E96 non conta come una normale cavalcatura per quella squadra.
UO.Exec("dismount") chiama lo stesso gestore e utilizza la stessa protezione da replay. Non è possibile passare parametri nella riga di smontaggio: un argomento aggiuntivo causa un errore e non invia la richiesta.

Script C# autonomi

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.

Esempio semplice

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

1. Richiedi smontaggio - script diretto

Parametri e flusso di esecuzione:

Non ci sono parametri. Non esiste nemmeno un valore restituito.

UO.Dismount();

2. Verifica la presenza dell'elemento montato prima della richiesta - funzione script

Parametri e flusso di esecuzione:

cavalcato — ID dell'elemento del livello, non il bersaglio per chiamare nuovamente Mount. Dismount accetta zero argomenti.

return  RunScenario();
 object? RunScenario()
{
    var ridden = UO.ObjAtLayer(25);
    if (Truth(ridden == 0))
    {
        UO.Print("No loaded mount layer");
        return null;
    }

    UO.Print("Mounted item ID: " + Convert.ToString(ridden));
    UO.Dismount();
    return null;
}

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

3. Completa la funzione di attesa del livello vuoto - Classe di script

Parametri e flusso di esecuzione:

L'helper restituisce true se il livello è già vuoto o è diventato vuoto entro le aspettative. Non invia più di una richiesta.
Questo è un controllo dello stato del client dopo la risposta del server, non del valore restituito di UO.Dismount.

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 dismounted = await TryDismount();
        UO.Print("Mount layer empty: " + Convert.ToString(dismounted));
        return null;
    }

    async Task<dynamic> TryDismount()
    {
        if (Truth(UO.ObjAtLayer(25) == 0))
        {
            return true;
        }

        UO.Dismount();
        var attempts = 0;
        while (Truth(attempts < 20))
        {
            if (Truth(UO.ObjAtLayer(25) == 0))
            {
                return true;
            }

            await Delay(50);
            attempts = attempts + 1;
        }

        return false;
    }

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

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

`UO.Dismount()` — `UO.Dismount()`

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "dismount": bridge.Dismount(); break;

UO.Dress

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

Firme C#

void UO.Dress(object? name);

Ripristina un set di vestiti con nome salvato in precedenza.

Parametri

name — Nome della stringa del set, ad esempio "viaggio" o "battaglia". I nomi non fanno distinzione tra maiuscole e minuscole. L'abbigliamento e i set di armi sono tenuti separatamente: in entrambi è consentito lo stesso nome. Questa non è una cosa ID o un nome file. Solo SetDress consente l'assenza di un nome: quindi viene registrato un set separato per DressSavedSet/EquipDressSet.

Valore restituito

void - nessun valore. Chiama su una linea separata; non assegnare il risultato né confrontarlo con true. Il salvataggio e l'eliminazione modificano la voce, non l'attrezzatura.

Comportamento

Abbigliamento: strati 3,4,5,6,7,8,10,12,13,14,17,18,19,20,22,23,24. Armi: solo 1 e 2. Capelli, barba, zaino, animale e banca non sono inclusi in questi set.
Le cose specifiche serial già caricate vengono registrate nei propri livelli. Salvando nuovamente lo stesso nome si sostituisce la voce. Anche gli strati vuoti hanno senso: una volta ripristinati, il corrispondente strato occupato verrà rilasciato nel proprio zaino. Pertanto, un set completamente vuoto salvato rimuove gli elementi dai suoi livelli.
Il set viene archiviato nello stato di runtime. La chiamata stessa non crea un file e non garantisce che il set verrà trasferito su un altro profilo o su un nuovo runtime. Innanzitutto, salva il set desiderato nel suo stato utilizzato. Il caricamento/salvataggio dello stato generale del client è un meccanismo separato.
Una corrispondenza esatta tra il ID corrente e quello salvato viene saltata, senza essere utilizzata/rilanciata nuovamente. Un elemento mancante non viene sostituito da un type simile. Il fallimento di un'operazione non cancella quelle riuscite e non interferisce con i tentativi delle altre; Non esiste un rollback automatico. Hai bisogno di connessione e materiale caricato. Quando rimosso, viene utilizzato un vero zaino.
UO.Set("equipfordress", 0) seleziona la richiesta di utilizzo dell'oggetto (modalità iniziale); valore diverso da zero: raccogli/equipaggia. Lo strato indossabile desiderato viene controllato in entrambe le modalità. Un capo già indossato non può essere cambiato con l'uso ripetuto. DressSpeed è valido dopo la richiesta accettata, il ritiro rispetta inoltre DropDelay.
Dress e Arm restituiscono void anche in caso di guasto. Il messaggio che le richieste sono state accettate non significa conferma da parte del server. Per la continuazione dipendente dall'indossamento, controllare gli strati effettivi con aspettative limitate.
UO.SetDress · UO.Dress · UO.DressSavedSet · UO.SetArm · UO.Arm · UO.DressSpeed

Script C# autonomi

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.

Esempio semplice

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

1. Uso diretto - script diretto

Parametri e flusso di esecuzione:

Il set richiesto deve essere salvato in precedenza nello stesso stato di runtime. Non chiamare SetDress/SetArm subito prima di ogni ripristino: questo sovrascriverà la destinazione con gli elementi correnti.

UO.Dress("travel");

2. Nomi e modalità query - Funzione script

Parametri e flusso di esecuzione:

Un equipfordress diverso da zero seleziona raccolta/equipaggiamento; 350 — millisecondi DressSpeed. Queste impostazioni rimangono in fase di esecuzione dopo l'esempio. La rimozione e l'indossamento vengono decisi dal server.

return  RunScenario();
 object? RunScenario()
{
    UO.Set("equipfordress", 1);
    UO.DressSpeed(350);
    UO.Dress("travel");
    return null;
}

3. Script di supporto completo: classe di script

Parametri e flusso di esecuzione:

lasttarget — ID cose che dovrebbero essere incluse in un set precedentemente salvato. Lo strato di controllo 3 significa scarpe, 1 significa mano destra. AwaitSlot effettua controlli fino a 20 con una pausa di 100 ms e non ripete il comando. Ciò conferma solo l'elemento selezionato, non l'intero set.

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 expected = Asc(UO.GetSerial("lasttarget"), 0);
        if (Truth(expected == 0))
        {
            return 0;
        }

        UO.Dress("travel");
        return AwaitSlot(3, expected);
        return null;
    }

    dynamic AwaitSlot(dynamic layer, dynamic expected)
    {
        for (int attempt = (int)(1); attempt <= 20; attempt += (int)(1))
        {
            if (Truth(UO.ObjAtLayerEx(layer, UO.Self()) == expected))
            {
                return 1;
            }

            UO.Wait(100);
        }

        return 0;
    }

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

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

`UO.Dress(name)` — `UO.Dress(String)`

Parametri: name (String)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Dress.
InjectionScript.Runtime.InjectionApiUO.Equip: Equip(name, dressSets, dressLayers, "Clothing set requests processed.", "No clothing set with setdress.").

Codice interno di implementazione; non è uno script autonomo.

public void Dress(string name)

            => Equip(name, dressSets, dressLayers, "Clothing set requests processed.", "No clothing set with setdress.");

UO.DressSavedSet

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

Firme C#

dynamic UO.DressSavedSet();

Ripristina un set di vestiti salvato chiamando UO.SetDress() senza nome.

Parametri

Non ci sono parametri.

Valore restituito

Infatti, flag numerico int: 1 (condizione soddisfatta) - tutte le richieste necessarie sono accettate localmente o i livelli necessari sono già abbinati; 0 (condizione non soddisfatta) - nessuna composizione, nessuna connessione o almeno una richiesta è stata rifiutata. Registrazione object? lo consente int. Questo non è ID, il numero di articoli indossati o la conferma del server.

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.

Comportamento

Abbigliamento: strati 3,4,5,6,7,8,10,12,13,14,17,18,19,20,22,23,24. Armi: solo 1 e 2. Capelli, barba, zaino, animale e banca non sono inclusi in questi set.
Le cose specifiche serial già caricate vengono registrate nei propri livelli. Salvando nuovamente lo stesso nome si sostituisce la voce. Anche gli strati vuoti hanno senso: una volta ripristinati, il corrispondente strato occupato verrà rilasciato nel proprio zaino. Pertanto, un set completamente vuoto salvato rimuove gli elementi dai suoi livelli.
Il set viene archiviato nello stato di runtime. La chiamata stessa non crea un file e non garantisce che il set verrà trasferito su un altro profilo o su un nuovo runtime. Innanzitutto, salva il set desiderato nel suo stato utilizzato. Il caricamento/salvataggio dello stato generale del client è un meccanismo separato.
Una corrispondenza esatta tra il ID corrente e quello salvato viene saltata, senza essere utilizzata/rilanciata nuovamente. Un elemento mancante non viene sostituito da un type simile. Il fallimento di un'operazione non cancella quelle riuscite e non interferisce con i tentativi delle altre; Non esiste un rollback automatico. Hai bisogno di connessione e materiale caricato. Quando rimosso, viene utilizzato un vero zaino.
UO.Set("equipfordress", 0) seleziona la richiesta di utilizzo dell'oggetto (modalità iniziale); valore diverso da zero: raccogli/equipaggia. Lo strato indossabile desiderato viene controllato in entrambe le modalità. Un capo già indossato non può essere cambiato con l'uso ripetuto. DressSpeed è valido dopo la richiesta accettata, il ritiro rispetta inoltre DropDelay.
Dress e Arm restituiscono null anche in caso di guasto. Il messaggio che le richieste sono state accettate non significa conferma da parte del server. Per la continuazione dipendente dall'indossamento, controllare gli strati effettivi con aspettative limitate.
UO.SetDress · UO.Dress · UO.DressSavedSet · UO.SetArm · UO.Arm · UO.DressSpeed

Script C# autonomi

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.

Esempio semplice

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

1. Uso diretto - script diretto

Parametri e flusso di esecuzione:

Il set richiesto deve essere salvato in precedenza nello stesso stato di runtime. Non chiamare SetDress/SetArm subito prima di ogni ripristino: questo sovrascriverà la destinazione con gli elementi correnti.

return UO.DressSavedSet();

2. Nomi e modalità query - Funzione script

Parametri e flusso di esecuzione:

Un equipfordress diverso da zero seleziona raccolta/equipaggiamento; 350 — millisecondi DressSpeed. Queste impostazioni rimangono in fase di esecuzione dopo l'esempio. La rimozione e l'indossamento vengono decisi dal server.

return  RunScenario();
 object? RunScenario()
{
    UO.Set("equipfordress", 1);
    UO.DressSpeed(350);
    return UO.DressSavedSet();
    return null;
}

3. Script di supporto completo: classe di script

Parametri e flusso di esecuzione:

lasttarget — ID cose che dovrebbero essere incluse in un set precedentemente salvato. Lo strato di controllo 3 significa scarpe, 1 significa mano destra. AwaitSlot effettua controlli fino a 20 con una pausa di 100 ms e non ripete il comando. Ciò conferma solo l'elemento selezionato, non l'intero set.

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 expected = Asc(UO.GetSerial("lasttarget"), 0);
        if (Truth(expected == 0))
        {
            return 0;
        }

        if (!(Truth(UO.DressSavedSet())))
        {
            return 0;
        }

        return AwaitSlot(3, expected);
        return null;
    }

    dynamic AwaitSlot(dynamic layer, dynamic expected)
    {
        for (int attempt = (int)(1); attempt <= 20; attempt += (int)(1))
        {
            if (Truth(UO.ObjAtLayerEx(layer, UO.Self()) == expected))
            {
                return 1;
            }

            UO.Wait(100);
        }

        return 0;
    }

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

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

`UO.DressSavedSet()` — `UO.DressSavedSet()`

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
InjectionScript.Runtime.InjectionApiUO.Equip: Equip("__stealth_saved_set__", dressSets, dressLayers, "Clothing set requests processed.", "No clothing set with setdress.").

Codice interno di implementazione; non è uno script autonomo.

case "dresssavedset":

                case "equipdressset": return new InjectionValue(Equip("__stealth_saved_set__", dressSets, dressLayers, "Clothing set requests processed.", "No clothing set with setdress."));

UO.DressSpeed

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

Firme C#

dynamic UO.DressSpeed();
dynamic UO.DressSpeed(object? value);

Legge o imposta la pausa tra le operazioni di vestizione/svestizione nel runtime corrente. Aiuta a evitare di inviare una serie di azioni troppo rapidamente per le regole del server.

Parametri

value - Millisecondi opzionali. Senza discussione: lettura; con argomento il valore è limitato a 10..10000. Il valore iniziale del runtime può essere 0 se il ritardo non è stato ancora specificato; Non puoi scrivere 0 usando questo comando.

Valore restituito

Nessun argomento: int, millisecondi attuali. Con argomento: null, non esiste alcun valore restituito; quindi leggere UO.DressSpeed() separatamente. Questo non è bool.

Comportamento

EquipItems/UnequipItems applica DressSpeed dopo l'operazione accettata prima dell'elemento successivo; Disarm/Undress - dopo ogni livello occupato. Il ritiro rispetta inoltre DropDelay quando il trasporto viene accettato. Le stesse impostazioni degli altri runtime non cambiano; l'accelerazione non prevale sulle limitazioni del server.
UO.EquipItems · UO.UnequipItems · UO.DressSpeed · UO.DropDelay · UO.ObjAtLayerEx

Script C# autonomi

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.

Esempio semplice

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

1. DressSpeed - 1 - sceneggiatura diretta

Parametri e flusso di esecuzione:

Leggere la pausa corrente e selezionare il minimo per la serie successiva; 0 indica un ritardo che non è stato ancora specificato.

var delay = UO.DressSpeed();
if (Truth(delay < 350))
{
    UO.DressSpeed(350);
}
return UO.DressSpeed();

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

2. DressSpeed — 2 — funzione di script

Parametri e flusso di esecuzione:

Impostare 350 ms e controllare separatamente il valore memorizzato. Non è possibile assegnare il risultato di un setter a una variabile: setter restituisce Unit.

return  RunScenario();
 object? RunScenario()
{
    UO.DressSpeed(350);
    return UO.DressSpeed();
    return null;
}

3. DressSpeed - 3 - classe dello scenario

Parametri e flusso di esecuzione:

ConfigureDressDelay accetta l'impostazione dello script. 15000 è limitato a 10000 ms; L'assistente restituisce i millisecondi effettivamente salvati.

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

     public object? RunScenario()
    {
        return ConfigureDressDelay(15000);
        return null;
    }

    dynamic ConfigureDressDelay(dynamic requested)
    {
        UO.DressSpeed(requested);
        return UO.DressSpeed();
    }
}

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

`UO.DressSpeed()` — `UO.DressSpeed()`

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
InjectionScript.Runtime.InjectionApiUO.SetDressSpeed: SetDressSpeed(Arg(0)).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).

Codice interno di implementazione; non è uno script autonomo.

case "dressspeed":

                    if (arguments.Length > 0) { SetDressSpeed(Arg(0)); return InjectionValue.Unit; }

                    return new InjectionValue(state.DressSpeed);

`UO.DressSpeed(value)` — `UO.DressSpeed(Any)`

Parametri: value (Any)

Risultato: dynamic / Any.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
InjectionScript.Runtime.InjectionApiUO.SetDressSpeed: SetDressSpeed(Arg(0)).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).

Codice interno di implementazione; non è uno script autonomo.

case "dressspeed":

                    if (arguments.Length > 0) { SetDressSpeed(Arg(0)); return InjectionValue.Unit; }

                    return new InjectionValue(state.DressSpeed);

UO.EnergyResist

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

Firme C#

int UO.EnergyResist();

Legge il campo di resistenza del personaggio attuale: energia.

Parametri

Non ci sono parametri.

Valore restituito

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.

Comportamento

Il comando non accetta argomenti. Usa le firme esatte sopra.
La lettura nel thread del gioco richiede Player.EnergyResistance 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.

Script C# autonomi

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.

Esempio semplice

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

1. Stampa valore salvato - script diretto

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.EnergyResist();
UO.Print("EnergyResistance: " + Convert.ToString(value));

2. Confronta due immagini: funzione script

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.EnergyResist();
    await Delay(500);
    var after = UO.EnergyResist();
    var difference = after - before;
    UO.Print("Resistance change: " + Convert.ToString(difference));
    return null;
}

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

3. Funzione completa di test della resistenza minima - Classe di script

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

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

`UO.EnergyResist()` — `UO.EnergyResist()`

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.EnergyResistance: bridge.EnergyResistance.

Codice interno di implementazione; non è uno script autonomo.

case "energyresist": return new InjectionValue(bridge.EnergyResistance);

UO.Equip

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

Firme C#

int UO.Equip(object? layer, object? id);

Equipaggia l'oggetto selezionato al livello specificato del tuo personaggio.

Parametri

layer - Numero del livello, ad esempio 1 - mano destra, 2 - sinistra. Equip e Unequip accettano anche un nome di livello, come "Rhand". WearItem utilizza un livello numerico. Lo strato deve corrispondere allo strato indossabile dell'articolo; non è graphic e non ID.
id - ID dell'oggetto specifico caricato: numero intero, stringa esadecimale, "lasttarget" o nome AddObject. Questo non è type. Esempio con 0x0F5E cercare prima la spada di graphic e ottenerla con ID.

Valore restituito

Flag numerico int: 1 (condizione soddisfatta) - operazione locale accettata, 0 (condizione non soddisfatta) - rifiuto. Questa non è una conferma del server, né ID, né una quantità. Il server potrebbe fallire in seguito; controllare l'attrezzatura effettiva dopo aver risposto.

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.

Comportamento

Sono necessari elementi caricati e trascinamento a mano libera. Una volta rimosso, è necessario lo zaino vero e proprio self: il GrabBag di riserva non viene utilizzato. Gli articoli sconosciuti, distrutti e non idonei vengono rifiutati. Gli oggetti di altre persone non possono essere rimossi tramite UnequipItems. Un insieme non è una transazione atomica.
EquipItems/UnequipItems applica DressSpeed dopo l'operazione accettata prima dell'elemento successivo; Disarm/Undress - dopo ogni livello occupato. Il ritiro rispetta inoltre DropDelay quando il trasporto viene accettato. Le stesse impostazioni degli altri runtime non cambiano; l'accelerazione non prevale sulle limitazioni del server.
Un modulo di chiamata errato, un nome di livello sconosciuto o un valore non convertibile in un numero possono causare un errore di script anziché 0. L'istantanea dell'attrezzatura contiene solo i dati che sono già stati caricati. Nell'assistente, ChangeAndConfirm layer=1 è la mano destra: per altro, passa il suo layer reale.
UO.EquipItems · UO.UnequipItems · UO.DressSpeed · UO.DropDelay · UO.ObjAtLayerEx

Script C# autonomi

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.

Esempio semplice

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

int item = UO.LastTarget();
if (item != 0)
    UO.Print("Accepted flag: " + UO.Equip(1, item));

1. Equip - Un elemento o livello selezionato - script diretto

Parametri e flusso di esecuzione:

Per prima cosa, seleziona l'oggetto appropriato nel gioco: lasttarget - è ID. Nell'esempio Equip/WearItem, il livello 1 richiede un'arma secondaria. Unequip(1) rimuove la mano destra; Disarm/Undress funzionano con i propri livelli fissi. Non ci sono replay automatici dopo un rifiuto.

var item = Asc(UO.GetSerial("lasttarget"), 0);
if (Truth(item == 0))
{
    return 0;
}
return UO.Equip(1, item);

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;

2. Equip - Due elementi e salvato ID - funzione script

Parametri e flusso di esecuzione:

Per equipaggiarlo, 0x0F5E è un esempio di spada, 0x1B76 è un esempio di scudo. FindType li cerca tra gli oggetti caricati nello zaino, ASC converte l'esadecimale restituito-ID. Per la rimozione vengono letti i propri livelli attuali. Se l'elemento richiesto non è disponibile, lo script termina. L'array memorizza due ID; Ogni elemento viene trasferito interamente.

return  RunScenario();
 object? RunScenario()
{
    var first = Asc(UO.FindType(0x0F5E, -1, "backpack"), 0);
    var second = Asc(UO.FindType(0x1B76, -1, "backpack"), 0);
    if (Truth(first == 0) || Truth(second == 0))
    {
        return 0;
    }

    UO.AddObject("saved_first", first);
    UO.AddObject("saved_second", second);
    var firstOk = UO.Equip(1, first);
    var secondOk = UO.Equip(2, second);
    return firstOk != 0 && secondOk != 0;
    return null;
}

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;

3. Equip - Funzione completa con attesa limitata - classe script

Parametri e flusso di esecuzione:

ChangeAndConfirm esegue il comando una volta. Quindi controlla lo stato attuale fino a 20 volte con una pausa di 100 ms. 1 - il controllo ha rilevato lo stato previsto, 0 - errore o attesa scaduta. Questo è il risultato del nostro helper, non un nuovo comando integrato. Anche richiamare l'operazione stessa potrebbe richiedere del tempo.

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 item = Asc(UO.GetSerial("lasttarget"), 0);
        if (Truth(item == 0))
        {
            return 0;
        }

        return ChangeAndConfirm(1, item);
        return null;
    }

    dynamic ChangeAndConfirm(dynamic layer, dynamic item)
    {
        if (Truth(item == 0))
        {
            return 0;
        }

        if (!(Truth(UO.Equip(layer, item))))
        {
            return 0;
        }

        for (int attempt = (int)(1); attempt <= 20; attempt += (int)(1))
        {
            if (Truth(UO.ObjAtLayerEx(layer, UO.Self()) == item))
            {
                return 1;
            }

            UO.Wait(100);
        }

        return 0;
    }

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

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

`UO.Equip(layer, id)` — `UO.Equip(Any,Any)`

Parametri: layer (Any/String), id (Any/Integer/String)

Risultato: int / Any.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "equip":

                    return new InjectionValue(arguments[0].Kind == InjectionValueKind.String ? Equip(Text(0), Arg(1)) : bridge.Equip(Arg(0), Arg(1)));

`UO.Equip(layer, id)` — `UO.Equip(String,Integer)`

Parametri: layer (Any/String), id (Any/Integer/String)

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Equip.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Equip: bridge.Equip(ConvertLayer(layer), id).
InjectionScript.Runtime.InjectionApiUO.ConvertLayer: ConvertLayer(layer).

Codice interno di implementazione; non è uno script autonomo.

public int Equip(string layer, int id) => bridge.Equip(ConvertLayer(layer), id);

`UO.Equip(layer, id)` — `UO.Equip(String,String)`

Parametri: layer (Any/String), id (Any/Integer/String)

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Equip.
InjectionScript.Runtime.InjectionApiUO.Equip: Equip(layer, GetObject(id)).
InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(id).

Codice interno di implementazione; non è uno script autonomo.

public int Equip(string layer, string id) => Equip(layer, GetObject(id));

UO.EquipDressSet

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

Firme C#

dynamic UO.EquipDressSet();

Nome alternativo DressSavedSet: ripristina lo stesso set di vestiti senza nome.

Parametri

Non ci sono parametri.

Valore restituito

Infatti, flag numerico int: 1 (condizione soddisfatta) - tutte le richieste necessarie sono accettate localmente o i livelli necessari sono già abbinati; 0 (condizione non soddisfatta) - nessuna composizione, nessuna connessione o almeno una richiesta è stata rifiutata. Registrazione object? lo consente int. Questo non è ID, il numero di articoli indossati o la conferma del server.

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.

Comportamento

Abbigliamento: strati 3,4,5,6,7,8,10,12,13,14,17,18,19,20,22,23,24. Armi: solo 1 e 2. Capelli, barba, zaino, animale e banca non sono inclusi in questi set.
Le cose specifiche serial già caricate vengono registrate nei propri livelli. Salvando nuovamente lo stesso nome si sostituisce la voce. Anche gli strati vuoti hanno senso: una volta ripristinati, il corrispondente strato occupato verrà rilasciato nel proprio zaino. Pertanto, un set completamente vuoto salvato rimuove gli elementi dai suoi livelli.
Il set viene archiviato nello stato di runtime. La chiamata stessa non crea un file e non garantisce che il set verrà trasferito su un altro profilo o su un nuovo runtime. Innanzitutto, salva il set desiderato nel suo stato utilizzato. Il caricamento/salvataggio dello stato generale del client è un meccanismo separato.
Una corrispondenza esatta tra il ID corrente e quello salvato viene saltata, senza essere utilizzata/rilanciata nuovamente. Un elemento mancante non viene sostituito da un type simile. Il fallimento di un'operazione non cancella quelle riuscite e non interferisce con i tentativi delle altre; Non esiste un rollback automatico. Hai bisogno di connessione e materiale caricato. Quando rimosso, viene utilizzato un vero zaino.
UO.Set("equipfordress", 0) seleziona la richiesta di utilizzo dell'oggetto (modalità iniziale); valore diverso da zero: raccogli/equipaggia. Lo strato indossabile desiderato viene controllato in entrambe le modalità. Un capo già indossato non può essere cambiato con l'uso ripetuto. DressSpeed è valido dopo la richiesta accettata, il ritiro rispetta inoltre DropDelay.
Dress e Arm restituiscono null anche in caso di guasto. Il messaggio che le richieste sono state accettate non significa conferma da parte del server. Per la continuazione dipendente dall'indossamento, controllare gli strati effettivi con aspettative limitate.
UO.SetDress · UO.Dress · UO.DressSavedSet · UO.SetArm · UO.Arm · UO.DressSpeed

Script C# autonomi

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.

Esempio semplice

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

1. Uso diretto - script diretto

Parametri e flusso di esecuzione:

Il set richiesto deve essere salvato in precedenza nello stesso stato di runtime. Non chiamare SetDress/SetArm subito prima di ogni ripristino: questo sovrascriverà la destinazione con gli elementi correnti.

return UO.EquipDressSet();

2. Nomi e modalità query - Funzione script

Parametri e flusso di esecuzione:

Un equipfordress diverso da zero seleziona raccolta/equipaggiamento; 350 — millisecondi DressSpeed. Queste impostazioni rimangono in fase di esecuzione dopo l'esempio. La rimozione e l'indossamento vengono decisi dal server.

return  RunScenario();
 object? RunScenario()
{
    UO.Set("equipfordress", 1);
    UO.DressSpeed(350);
    return UO.EquipDressSet();
    return null;
}

3. Script di supporto completo: classe di script

Parametri e flusso di esecuzione:

lasttarget — ID cose che dovrebbero essere incluse in un set precedentemente salvato. Lo strato di controllo 3 significa scarpe, 1 significa mano destra. AwaitSlot effettua controlli fino a 20 con una pausa di 100 ms e non ripete il comando. Ciò conferma solo l'elemento selezionato, non l'intero set.

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 expected = Asc(UO.GetSerial("lasttarget"), 0);
        if (Truth(expected == 0))
        {
            return 0;
        }

        if (!(Truth(UO.EquipDressSet())))
        {
            return 0;
        }

        return AwaitSlot(3, expected);
        return null;
    }

    dynamic AwaitSlot(dynamic layer, dynamic expected)
    {
        for (int attempt = (int)(1); attempt <= 20; attempt += (int)(1))
        {
            if (Truth(UO.ObjAtLayerEx(layer, UO.Self()) == expected))
            {
                return 1;
            }

            UO.Wait(100);
        }

        return 0;
    }

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

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

`UO.EquipDressSet()` — `UO.EquipDressSet()`

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
InjectionScript.Runtime.InjectionApiUO.Equip: Equip("__stealth_saved_set__", dressSets, dressLayers, "Clothing set requests processed.", "No clothing set with setdress.").

Codice interno di implementazione; non è uno script autonomo.

case "dresssavedset":

                case "equipdressset": return new InjectionValue(Equip("__stealth_saved_set__", dressSets, dressLayers, "Clothing set requests processed.", "No clothing set with setdress."));

UO.EquipItems

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

Firme C#

dynamic UO.EquipItems(object? items);

Equipaggia un oggetto o una serie di oggetti. Lo strato di ogni articolo è determinato dai suoi dati indossabili, quindi l'articolo può essere indossato da uno zaino.

Parametri

items - Richiesto ID o array ID di elementi. Gli elementi dell'array sono numeri o stringhe esadecimali numeriche. Il singolo argomento accetta anche "lasttarget"/nome AddObject. Per un array, utilizzare la dichiarazione di variabile items[1] per due elementi agli indici 0 e 1. Vengono trasmesse cose, non numeri di livello e non type.

Valore restituito

Flag numerico int: 1 (condizione soddisfatta) - operazione locale accettata, 0 (condizione non soddisfatta) - rifiuto. Questa non è una conferma del server, né ID, né una quantità. Il server potrebbe fallire in seguito; controllare l'attrezzatura effettiva dopo aver risposto.

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.

Comportamento

Sono necessari elementi caricati e trascinamento a mano libera. Una volta rimosso, è necessario lo zaino vero e proprio self: il GrabBag di riserva non viene utilizzato. Gli articoli sconosciuti, distrutti e non idonei vengono rifiutati. Gli oggetti di altre persone non possono essere rimossi tramite UnequipItems. Un insieme non è una transazione atomica.
EquipItems/UnequipItems applica DressSpeed dopo l'operazione accettata prima dell'elemento successivo; Disarm/Undress - dopo ogni livello occupato. Il ritiro rispetta inoltre DropDelay quando il trasporto viene accettato. Le stesse impostazioni degli altri runtime non cambiano; l'accelerazione non prevale sulle limitazioni del server.
Un modulo di chiamata errato, un nome di livello sconosciuto o un valore non convertibile in un numero possono causare un errore di script anziché 0. L'istantanea dell'attrezzatura contiene solo i dati che sono già stati caricati. Nell'assistente, ChangeAndConfirm layer=1 è la mano destra: per altro, passa il suo layer reale.
Per un array, 1 significa che tutte le operazioni elencate sono accettate; in caso di eventuale rifiuto viene restituito 0. Gli elementi rimanenti vengono ancora elaborati, non è previsto alcun rollback. Un array vuoto produce 1 senza alcuna azione. Disarm/Undress dà 1 anche quando i layer richiesti sono già vuoti; il fallimento parziale dà 0.
UO.EquipItems · UO.UnequipItems · UO.DressSpeed · UO.DropDelay · UO.ObjAtLayerEx

Script C# autonomi

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.

Esempio semplice

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

1. EquipItems - Un elemento o livello selezionato - script diretto

Parametri e flusso di esecuzione:

Per prima cosa, seleziona l'oggetto appropriato nel gioco: lasttarget - è ID. Nell'esempio Equip/WearItem, il livello 1 richiede un'arma secondaria. Unequip(1) rimuove la mano destra; Disarm/Undress funzionano con i propri livelli fissi. Non ci sono replay automatici dopo un rifiuto.

var item = Asc(UO.GetSerial("lasttarget"), 0);
if (Truth(item == 0))
{
    return 0;
}
return UO.EquipItems(item);

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;

2. EquipItems - Due elementi e salvati ID - funzione script

Parametri e flusso di esecuzione:

Per equipaggiarlo, 0x0F5E è un esempio di spada, 0x1B76 è un esempio di scudo. FindType li cerca tra gli oggetti caricati nello zaino, ASC converte l'esadecimale restituito-ID. Per la rimozione vengono letti i propri livelli attuali. Se l'elemento richiesto non è disponibile, lo script termina. L'array memorizza due ID; Ogni elemento viene trasferito interamente.

return  RunScenario();
 object? RunScenario()
{
    var first = Asc(UO.FindType(0x0F5E, -1, "backpack"), 0);
    var second = Asc(UO.FindType(0x1B76, -1, "backpack"), 0);
    if (Truth(first == 0) || Truth(second == 0))
    {
        return 0;
    }

    UO.AddObject("saved_first", first);
    UO.AddObject("saved_second", second);
    dynamic[] items = new dynamic[checked((int)(1) + 1)];
    items[0] = first;
    items[1] = second;
    return UO.EquipItems(items);
    return null;
}

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;

3. EquipItems - Funzione completa con attesa limitata - classe script

Parametri e flusso di esecuzione:

ChangeAndConfirm esegue il comando una volta. Quindi controlla lo stato attuale fino a 20 volte con una pausa di 100 ms. 1 - il controllo ha rilevato lo stato previsto, 0 - errore o attesa scaduta. Questo è il risultato del nostro helper, non un nuovo comando integrato. Anche richiamare l'operazione stessa potrebbe richiedere del tempo.

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 item = Asc(UO.GetSerial("lasttarget"), 0);
        if (Truth(item == 0))
        {
            return 0;
        }

        return ChangeAndConfirm(1, item);
        return null;
    }

    dynamic ChangeAndConfirm(dynamic layer, dynamic item)
    {
        if (Truth(item == 0))
        {
            return 0;
        }

        if (!(Truth(UO.EquipItems(item))))
        {
            return 0;
        }

        for (int attempt = (int)(1); attempt <= 20; attempt += (int)(1))
        {
            if (Truth(UO.ObjAtLayerEx(layer, UO.Self()) == item))
            {
                return 1;
            }

            UO.Wait(100);
        }

        return 0;
    }

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

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

`UO.EquipItems(items)` — `UO.EquipItems(Any)`

Parametri: items (Any)

Risultato: dynamic / Any.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
InjectionScript.Runtime.InjectionApiUO.ChangeEquipmentItems: ChangeEquipmentItems(ArrayArg(0), true).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::ArrayArg: ArrayArg(0).

Codice interno di implementazione; non è uno script autonomo.

case "equipitems":

                    return new InjectionValue(ChangeEquipmentItems(ArrayArg(0), true));

UO.EquipLastWeapon

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

Firme C#

void UO.EquipLastWeapon();

Richiede il riequipaggiamento degli ultimi oggetti salvati per la mano destra e sinistra.

Parametri

Non ci sono parametri.

Valore restituito

void: nessun valore restituito.

Comportamento

Bridge memorizza _lastRightHand e _lastLeftHand. Una destra diversa da zero serial viene trasmessa Equip(OneHanded), una sinistra diversa da zero - Equip(TwoHanded). Le voci vuote vengono saltate. Queste sono due possibili richieste, non un ripristino confermato atomicamente da parte del server.

Script C# autonomi

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.

Esempio semplice

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

1. Ripristina arma - script diretto

Parametri e flusso di esecuzione:

Vengono utilizzate solo le mani del bridge serial salvate.

UO.EquipLastWeapon();

2. Se c'è una connessione - funzione script

Parametri e flusso di esecuzione:

Il test della connessione viene eseguito prima dell'invio delle richieste.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Connected()))
    {
        UO.EquipLastWeapon();
    }

    return null;
}

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

3. Procedura di ripristino - Classe di script

Parametri e flusso di esecuzione:

Un aiutante completamente dichiarato provoca il ripristino di un set di mani.

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()
    {
        RestoreWeapons();
        return null;
    }

    void RestoreWeapons()
    {
        UO.EquipLastWeapon();
    }
}

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

`UO.EquipLastWeapon()` — `UO.EquipLastWeapon()`

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "equiplastweapon": bridge.EquipLastWeapon(); return InjectionValue.Unit;

UO.EquipT

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

Firme C#

void UO.EquipT(object? layer, object? @type);

Parametri

layer — Livello attrezzatura. La linea "Rhand" è la mano destra (1), "Lhand" è la mano sinistra (2); è accettabile anche un numero numerico. Tutti i nomi riconosciuti sono elencati nella tabella dei livelli. La stringa "1" non sostituisce il numero 1: un nome di stringa sconosciuto causa un errore. Seleziona il livello attuale dell'oggetto stesso: il comando non cambia il suo slot valido.
type - Un oggetto graphic, ad esempio 0x0F51 - un pugnale. Non è serial di una cosa particolare e non graphic di un corpo mobile. Un numero o una stringa esadecimale numerica. Il colore non è specificato: viene cercato qualsiasi hue; la ricerca include ricorsivamente i sottocontenitori caricati nello zaino. -1/0xFFFF poiché le ricerche con caratteri jolly qui sono praticamente inutili per la scelta delle armi: verrà presa la prima cosa che potrebbe non corrispondere al layer.

Valore restituito

void: questo modulo C# non restituisce un valore. Non assegnare la sua chiamata a una variabile e non usarla in if. Per verificare l'accettazione di una richiesta con due argomenti interi, utilizzare UO.Equipt. In entrambi i casi, controllare l'effettiva attrezzatura dopo che il server ha risposto tramite ObjAtLayer e GetType.

Comportamento

Entrambi gli argomenti sono obbligatori. Prima FindType cerca un oggetto nello zaino, poi Equip ne verifica l'idoneità. La ricerca aggiorna i risultati complessivi FindItem/FindCount/GetFoundItems. Se ci sono più corrispondenze viene selezionato il primo elemento idoneo alla ricerca; Non esiste una scelta separata per qualità, hue o nome.
Il cliente controlla la bandiera indossabile, lo strato effettivo dell'oggetto (1..29) e la capacità di sollevarlo. L'articolo deve essere caricato. Il server decide inoltre se è consentito indossarlo; una richiesta locale accettata non dimostra il successo.
Se manca un articolo, il modulo void visualizza il messaggio Nessun articolo trovato; la forma numerica restituisce 0. Se devi selezionare un elemento specifico per colore/serial, utilizza FindType e Equip separati. UO.Equip prende ID dell'oggetto trovato.
Durante l'attesa di una risposta, non avviare contemporaneamente il trasferimento di un altro articolo. Controlla le modifiche al livello anziché ripetere l'azione all'infinito.

Script C# autonomi

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.

Esempio semplice

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

1. Equipaggia il pugnale in base al nome del livello di stringa: script diretto

Parametri e flusso di esecuzione:

La linea Rhand seleziona il livello di destra. Il pugnale deve essere accessibile in uno zaino carico. Qualsiasi colore; il numero di argomenti è sempre due.

if (Truth(UO.Connected()))
{
    UO.EquipT("Rhand", 0x0F51);
}

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

2. Gestire l'errore del modulo numero: funzione dello script

Parametri e flusso di esecuzione:

1 - livello, 0x0F51 - type. La stringa C# forma EquipT restituisce void; L'accettazione di una richiesta non può essere verificata dal suo esito. 300 ms - breve attesa ad esempio; l'assenza di qualcosa dopo non dimostra un guasto definitivo del server.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    UO.EquipT("Rhand", 0x0F51);
    await Delay(300);
    var worn = UO.ObjAtLayer(1);
    if (Truth(worn != 0) && Truth(UO.GetType(worn) == 0x0F51))
    {
        UO.AddObject("equipped_dagger", worn);
    }

    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;

3. Funzione completa: indossa e attendi la classe di scenario type desiderata

Parametri e flusso di esecuzione:

timeoutMs=2000 specifica l'attesa massima in millisecondi. Il controllo ogni 50 ms non invia riequipaggiamento. Il true di questa funzione personalizzata significa che il cliente vede già il type desiderato sul livello; questo è un controllo più forte dell'accettazione della richiesta Equipt restituita.

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(UO.Connected()) && !(Truth(await EnsureDagger(2000))))
        {
            UO.Print("Dagger was not confirmed within the timeout");
        }

        return null;
    }

    async Task<dynamic> EnsureDagger(dynamic timeoutMs)
    {
        var worn = UO.ObjAtLayer(1);
        if (Truth(worn != 0) && Truth(UO.GetType(worn) == 0x0F51))
        {
            return true;
        }

        UO.EquipT("Rhand", 0x0F51);
        var started = Now();
        while (Truth(Now() - started < timeoutMs))
        {
            await Delay(50);
            worn = UO.ObjAtLayer(1);
            if (Truth(worn != 0) && Truth(UO.GetType(worn) == 0x0F51))
            {
                return true;
            }
        }

        return false;
    }

    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;
    private int Now() => global::ClassicUO.CSharp.CSharpScriptContext.Current.Now();
}

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

`UO.EquipT(layer, type)` — `UO.EquipT(Any,Any)`

Parametri: layer (Any), type (Any)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.EquipT.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.FindType: bridge.FindType(ResolveType(type), -1, bridge.Backpack, -1, true).
InjectionScript.Runtime.InjectionApiUO.ResolveType: ResolveType(type).
InjectionScript.Runtime.InjectionApiUO.SystemMessage: SystemMessage("No item found.").
InjectionScript.Runtime.InjectionApiUO.Equip: Equip(layer.String, obj).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Equip: bridge.Equip(NumberConversions.ToInt(layer), obj).
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(layer).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Backpack: bridge.Backpack.

Codice interno di implementazione; non è uno script autonomo.

public void EquipT(InjectionValue layer, InjectionValue type)

        {

            var obj = bridge.FindType(ResolveType(type), -1, bridge.Backpack, -1, true);

            if (obj == 0)

            {

                SystemMessage("No item found.");

                return;

            }



            if (layer.Kind == InjectionValueKind.String)

                Equip(layer.String, obj);

            else

                bridge.Equip(NumberConversions.ToInt(layer), obj);

        }

UO.Equipt

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

Firme C#

int UO.Equipt(object? layer, object? @type);

Parametri

layer / layer - numero intero del livello dell'apparecchiatura. Mano destra - 1, sinistra - 2. Scegli uno slot per oggetti reali.
type / type - un intero graphic di un oggetto, ad esempio 0x0F51 per un pugnale. Questo non è serial. Cerca qualsiasi hue nel contenuto caricato dello zaino e nei contenitori nidificati.

Valore restituito

Questo modulo C# restituisce int: 1 se il cliente ha accettato la richiesta di outfit, 0 altrimenti. Passa due numeri interi (numero del livello e graphic); i valori stringa selezionano un contratto runtime diverso e non sono adatti a questo modulo. La chiamata non attende la conferma del server. Per il nome di un livello di stringa, utilizzare UO.EquipT, che restituisce void.

Comportamento

Entrambi gli argomenti sono obbligatori. Prima FindType cerca un oggetto nello zaino, poi Equip ne verifica l'idoneità. La ricerca aggiorna i risultati complessivi FindItem/FindCount/GetFoundItems. Se ci sono più corrispondenze viene selezionato il primo elemento idoneo alla ricerca; Non esiste una scelta separata per qualità, hue o nome.
Il cliente controlla la bandiera indossabile, lo strato effettivo dell'oggetto (1..29) e la capacità di sollevarlo. L'articolo deve essere caricato. Il server decide inoltre se è consentito indossarlo; una richiesta locale accettata non dimostra il successo.
Se manca un articolo, il modulo null visualizza il messaggio Nessun articolo trovato; la forma numerica restituisce 0. Se devi selezionare un elemento specifico per colore/serial, utilizza FindType e Equip separati. UO.Equip prende ID dell'oggetto trovato.
Durante l'attesa di una risposta, non avviare contemporaneamente il trasferimento di un altro articolo. Controlla le modifiche al livello anziché ripetere l'azione all'infinito.

Script C# autonomi

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.

Esempio semplice

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

1. Richiedi l'equipaggiamento del pugnale tramite graphic - script diretto

Parametri e flusso di esecuzione:

Entrambi gli argomenti sono numeri interi: strato 1 e graphic del pugnale. Il valore 1 conferma che la richiesta è stata accettata dal client anziché dal server.

int accepted = UO.Equipt(1, 0x0F51);
UO.Print(accepted != 0 ? "Equip request accepted locally" : "Equip request not accepted");

2. Controlla lo slot dopo la richiesta - funzione script

Parametri e flusso di esecuzione:

L'attesa non sostituisce il controllo: viene letto ciò che è effettivamente presente sul livello. Lo script non ripete il trasferimento all'infinito.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    int accepted = UO.Equipt(1, 0x0F51);
    if (accepted == 0)
        return false;
    await WaitAsync(300);
    int worn = UO.ObjAtLayer(1);
    return worn != 0 && UO.GetType(worn) == 0x0F51;
    return null;
}

3. Indossalo solo quando l'articolo richiesto non è disponibile - classe scenario

Parametri e flusso di esecuzione:

Innanzitutto viene controllata l'attrezzatura attuale; Dopo una richiesta, la verifica è limitata a venti tentativi.

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()
    {
        return await EnsureDagger();
        return null;
    }

    async Task<bool> EnsureDagger()
    {
        int current = UO.ObjAtLayer(1);
        if (current != 0 && UO.GetType(current) == 0x0F51)
            return true;
        if (UO.Equipt(1, 0x0F51) == 0)
            return false;
        for (int attempt = 0; attempt < 20; attempt++)
        {
            await WaitAsync(100);
            current = UO.ObjAtLayer(1);
            if (current != 0 && UO.GetType(current) == 0x0F51)
                return true;
        }

        return false;
    }
}

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

`UO.Equipt(layer, type)` — `UO.Equipt(Integer,Integer)`

Parametri: layer (Integer), type (Integer)

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Equipt.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.FindType: bridge.FindType(type, -1, bridge.Backpack, -1, true).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Equip: bridge.Equip(layer, item).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Backpack: bridge.Backpack.

Codice interno di implementazione; non è uno script autonomo.

public int Equipt(int layer, int type)

        {

            int item = bridge.FindType(type, -1, bridge.Backpack, -1, true);

            return item == 0 ? 0 : bridge.Equip(layer, item);

        }

UO.FireResist

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

Firme C#

int UO.FireResist();

Legge il campo di resistenza del personaggio attuale: fuoco.

Parametri

Non ci sono parametri.

Valore restituito

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.

Comportamento

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.

Script C# autonomi

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.

Esempio semplice

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

1. Stampa valore salvato - script diretto

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.FireResist();
UO.Print("FireResistance: " + Convert.ToString(value));

2. Confronta due immagini: funzione script

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.FireResist();
    await Delay(500);
    var after = UO.FireResist();
    var difference = after - before;
    UO.Print("Resistance change: " + Convert.ToString(difference));
    return null;
}

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

3. Funzione completa di test della resistenza minima - Classe di script

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

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

`UO.FireResist()` — `UO.FireResist()`

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.FireResistance: bridge.FireResistance.

Codice interno di implementazione; non è uno script autonomo.

case "fireresist": return new InjectionValue(bridge.FireResistance);

UO.Flying

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

Firme C#

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

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.

Parametri

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

Valore restituito

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.

Comportamento

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.

Script C# autonomi

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.

Esempio semplice

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

1. Controlla la modalità prima della successiva istruzione di script: script diretto

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

2. Controlla il carattere precedentemente selezionato - la funzione dello script

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.Flying(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;

3. Richiedi un volo una volta e attendi il risultato: lezione di scenario

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.Flying()))
        {
            return true;
        }

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

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

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

        return UO.Flying();
    }

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

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

`UO.Flying()` — `UO.Flying()`

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Flying.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Flying: bridge.Flying(bridge.Self).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self: bridge.Self.

Codice interno di implementazione; non è uno script autonomo.

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

`UO.Flying(id)` — `UO.Flying(Any)`

Parametri: id (Any)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

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

UO.Frozen

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

Firme C#

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

Controlla il flag di paralisi del personaggio noto al client.

Parametri

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.

Valore restituito

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.

Comportamento

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.

Script C# autonomi

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.

Esempio semplice

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

1. Mettiti alla prova tramite true - script diretto

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

2. Controlla la funzione script mobile selezionata

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.Frozen(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;

3. Attesa limitata per la rimozione della paralisi - classe scenario

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

        if (Truth(UO.IsNPC("self")))
        {
            if (Truth(Truth(UO.Frozen()) == 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;
}

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

`UO.Frozen()` — `UO.Frozen()`

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [Frozen].
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.

`UO.Frozen(value)` — `UO.Frozen(Any)`

Parametri: value (Any)

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [Frozen].
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.

UO.GetARStatus

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

Firme C#

dynamic UO.GetARStatus();

Legge il flag per la riconnessione automatica della sessione del gestore corrente o del client globale.

Parametri

Non ci sono parametri.

Valore restituito

int 1 — la riconnessione automatica è abilitata; 0 — disabilitato.

Comportamento

SessionControl.AutoReconnect ha la priorità. Se manca SessionControl, viene utilizzato Impostazioni.GlobalSettings.Riconnetti. Si tratta di un'impostazione, non dello stato della connessione corrente o del numero di tentativi.

Script C# autonomi

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.

Esempio semplice

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

1. Impostazioni di lettura: script diretto

Parametri e flusso di esecuzione:

La lettura non si connette.

var enabled = UO.GetARStatus();
UO.Print(Convert.ToString(enabled));

2. Mappa su connessione - Funzione script

Parametri e flusso di esecuzione:

L'impostazione AR e la connessione effettiva sono due valori separati.

return  RunScenario();
 object? RunScenario()
{
    var enabled = UO.GetARStatus();
    var online = UO.Connected();
    UO.Print(Convert.ToString(enabled) + " " + Convert.ToString(online));
    return null;
}

3. Connessione manuale quando AR è spento - classe scenario

Parametri e flusso di esecuzione:

Connect consentito manualmente quando la riconnessione automatica è disabilitata.

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.GetARStatus() == 0) && !(Truth(UO.Connected())))
        {
            UO.Connect();
        }

        return null;
    }

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

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

`UO.GetARStatus()` — `UO.GetARStatus()`

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "getarstatus": return new InjectionValue(bridge.GetAutoReconnect());

UO.GetAlive

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

Firme C#

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

Verifica la presenza di un oggetto senza segno di morte.

Parametri

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.

Valore restituito

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 - il positivo serial esiste e non è contrassegnato come morto. Il famoso elemento fornisce anche 1: questo non è il filtro mobile. Un oggetto morto/mancante dà 0.

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.

Comportamento

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.

Script C# autonomi

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.

Esempio semplice

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

1. Controlla il tuo stato - script diretto

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

2. Oggetto selezionato e funzione completa ReadState - funzione script

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

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

3. Notare un cambiamento in mezzo secondo: classe di script

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.GetAlive();
        await Delay(500);
        var after = UO.GetAlive();
        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;
}

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

`UO.GetAlive()` — `UO.GetAlive()`

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [GetAlive].
InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Exists: bridge.Exists(serial).
InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::IsDeadState: IsDeadState(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 => serial > 0 && bridge.Exists(serial) != 0 && IsDeadState(serial) == 0 ? 1 : 0

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.

`UO.GetAlive(value)` — `UO.GetAlive(Any)`

Parametri: value (Any)

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [GetAlive].
InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Exists: bridge.Exists(serial).
InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::IsDeadState: IsDeadState(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 => serial > 0 && bridge.Exists(serial) != 0 && IsDeadState(serial) == 0 ? 1 : 0

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.

UO.GetArmor

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

Firme C#

int UO.GetArmor();

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

Parametri

Non ci sono parametri.

Valore restituito

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.

Comportamento

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.

Script C# autonomi

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.

Esempio semplice

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

1. Stampa valore salvato - script diretto

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.GetArmor();
UO.Print("PhysicalResistance: " + Convert.ToString(value));

2. Confronta due immagini: funzione script

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.GetArmor();
    await Delay(500);
    var after = UO.GetArmor();
    var difference = after - before;
    UO.Print("Resistance change: " + Convert.ToString(difference));
    return null;
}

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

3. Funzione completa di test della resistenza minima - Classe di script

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

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

`UO.GetArmor()` — `UO.GetArmor()`

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

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.

UO.GetColdResist

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

Firme C#

int UO.GetColdResist();

Legge il campo di resistenza del personaggio attuale: freddo.

Parametri

Non ci sono parametri.

Valore restituito

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.

Comportamento

Il comando non accetta argomenti. Usa le firme esatte sopra.
La lettura nel thread del gioco richiede Player.ColdResistance 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.

Script C# autonomi

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.

Esempio semplice

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

1. Stampa valore salvato - script diretto

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.GetColdResist();
UO.Print("ColdResistance: " + Convert.ToString(value));

2. Confronta due immagini: funzione script

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.GetColdResist();
    await Delay(500);
    var after = UO.GetColdResist();
    var difference = after - before;
    UO.Print("Resistance change: " + Convert.ToString(difference));
    return null;
}

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

3. Funzione completa di test della resistenza minima - Classe di script

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

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

`UO.GetColdResist()` — `UO.GetColdResist()`

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [GetColdResist].
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.ColdResistance: bridge.ColdResistance.

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

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

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddInteger.

UO.GetDead

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

Firme C#

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

Controlla la morte del personaggio.

Parametri

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.

Valore restituito

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 IsDead, 0 non ha segno o mobile è assente. HP=0 di per sé non significa morte.

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.

Comportamento

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.

Script C# autonomi

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.

Esempio semplice

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

1. Controlla il tuo stato - script diretto

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

2. Oggetto selezionato e funzione completa ReadState - funzione script

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

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

3. Notare un cambiamento in mezzo secondo: classe di script

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.GetDead();
        await Delay(500);
        var after = UO.GetDead();
        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;
}

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

`UO.GetDead()` — `UO.GetDead()`

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

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.

IsDeadState

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.

`UO.GetDead(value)` — `UO.GetDead(Any)`

Parametri: value (Any)

Risultato: int / Integer.

Durante la chiamata:

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.

IsDeadState

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.

UO.GetDex

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

Firme C#

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

Legge l'agilità attuale (Dexterity, DEX) del personaggio.

Parametri

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.

Valore restituito

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.

Comportamento

Sono supportati () per self e (ObjID) per un oggetto esplicito. Non ci sono altri argomenti facoltativi.
Legge Player.Dexterity 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.Dex(), UO.Dexterity(), UO.GetDex(), UO.GetDexterity().
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.

Script C# autonomi

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.

Esempio semplice

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

1. Leggere e visualizzare punti - script diretto

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.GetDex();
UO.Print("Dexterity: " + Convert.ToString(value));

2. Confronta due immagini: funzione script

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.GetDex();
    await Delay(1000);
    var after = UO.GetDex();
    var change = after - before;
    UO.Print("Change: " + Convert.ToString(change));
    return null;
}

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

3. Funzione di convalida dei requisiti completa - Classe di script

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

4. Seleziona il carattere tramite serial e il nome dell'oggetto - script diretto

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.GetDex(id);
    var byName = UO.GetDex("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;

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

`UO.GetDex()` — `UO.GetDex()`

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

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

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

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddInteger.

`UO.GetDex(objID)` — `UO.GetDex(Any)`

Parametri: objID (Any)

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetDexterity: bridge.GetDexterity(Arg(0)).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Dexterity: bridge.Dexterity.

Codice interno di implementazione; non è uno script autonomo.

case "getdex": return new InjectionValue(arguments.Length > 0 ? bridge.GetDexterity(Arg(0)) : bridge.Dexterity);

UO.GetDexterity

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

Firme C#

int UO.GetDexterity();

Legge l'agilità attuale (Dexterity, DEX) del personaggio.

Parametri

Non ci sono parametri.

Valore restituito

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.

Comportamento

Il comando non accetta argomenti. Usa le firme esatte sopra.
Legge Player.Dexterity 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.Dex(), UO.Dexterity(), UO.GetDex(), UO.GetDexterity().

Script C# autonomi

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.

Esempio semplice

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

1. Leggere e visualizzare punti - script diretto

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.GetDexterity();
UO.Print("Dexterity: " + Convert.ToString(value));

2. Confronta due immagini: funzione script

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.GetDexterity();
    await Delay(1000);
    var after = UO.GetDexterity();
    var change = after - before;
    UO.Print("Change: " + Convert.ToString(change));
    return null;
}

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

3. Funzione di convalida dei requisiti completa - Classe di script

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

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

`UO.GetDexterity()` — `UO.GetDexterity()`

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

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

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

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddInteger.

UO.GetEnergyResist

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

Firme C#

int UO.GetEnergyResist();

Legge il campo di resistenza del personaggio attuale: energia.

Parametri

Non ci sono parametri.

Valore restituito

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.

Comportamento

Il comando non accetta argomenti. Usa le firme esatte sopra.
La lettura nel thread del gioco richiede Player.EnergyResistance 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.

Script C# autonomi

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.

Esempio semplice

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

1. Stampa valore salvato - script diretto

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.GetEnergyResist();
UO.Print("EnergyResistance: " + Convert.ToString(value));

2. Confronta due immagini: funzione script

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.GetEnergyResist();
    await Delay(500);
    var after = UO.GetEnergyResist();
    var difference = after - before;
    UO.Print("Resistance change: " + Convert.ToString(difference));
    return null;
}

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

3. Funzione completa di test della resistenza minima - Classe di script

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

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

`UO.GetEnergyResist()` — `UO.GetEnergyResist()`

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [GetEnergyResist].
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.EnergyResistance: bridge.EnergyResistance.

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

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

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddInteger.

ClassicUO — Bad Newbie & C# Scripts IDE

IT UO Topic character

Carattere

Sezioni

Tutti i comandi del tema

Identità

Statistiche

Stato

Resiste

Attrezzatura

Dress / Undress

Arm / Disarm

Mount / Dismount

Bambola di carta

Livelli di caratteri

Esempi sull'argomento

UO.HP

UO.ObjAtLayer

Parti del riferimento

Riferimento completo dei comandi

UO.Alive

Firme C#

Parametri

Valore restituito

Comportamento

Script C# autonomi

Esempio semplice

1. Controlla il tuo stato - script diretto

2. Oggetto selezionato e funzione completa ReadState - funzione script

3. Notare un cambiamento in mezzo secondo: classe di script

Implementazione del comando

UO.Alive() — UO.Alive()

UO.Alive(value) — UO.Alive(Any)

UO.Arm

Firme C#

Parametri

Valore restituito

Comportamento

Script C# autonomi

Esempio semplice

1. Uso diretto - script diretto

2. Nomi e modalità query - Funzione script

3. Script di supporto completo: classe di script

Implementazione del comando

UO.Arm(name) — UO.Arm(String)

UO.Armor

Firme C#

Parametri

Valore restituito

Comportamento

Script C# autonomi

Esempio semplice

1. Stampa valore salvato - script diretto

2. Confronta due immagini: funzione script

3. Funzione completa di test della resistenza minima - Classe di script

Implementazione del comando

UO.Armor() — UO.Armor()

UO.CharName

Firme C#

Parametri

Valore restituito

Comportamento

Script C# autonomi

Esempio semplice

1. Mostra testo dopo il login - script diretto

2. Aggiungi testo al messaggio di registro - funzione script

3. Confronta due istantanee: classe scenario

Implementazione del comando

UO.CharName() — UO.CharName()

UO.CharTitle

Firme C#

Parametri

Valore restituito

Comportamento

Script C# autonomi

Esempio semplice

1. Mostra testo dopo il login - script diretto

2. Aggiungi testo al messaggio di registro - funzione script

3. Confronta due istantanee: classe scenario

Implementazione del comando

UO.CharTitle() — UO.CharTitle()

`UO.Alive()` — `UO.Alive()`

`UO.Alive(value)` — `UO.Alive(Any)`

`UO.Arm(name)` — `UO.Arm(String)`

`UO.Armor()` — `UO.Armor()`

`UO.CharName()` — `UO.CharName()`

`UO.CharTitle()` — `UO.CharTitle()`

`UO.CharacterTitle()` — `UO.CharacterTitle()`

`UO.ColdResist()` — `UO.ColdResist()`

`UO.Dead()` — `UO.Dead()`

`UO.Dead(id)` — `UO.Dead(Any)`

`UO.Dex()` — `UO.Dex()`

`UO.Dexterity()` — `UO.Dexterity()`