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

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

1 · 2 · 3 · 4 · 5

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

int UO.Undress();

Rimuove vestiti e armature dagli strati 3,4,5,6,7,8,10,12,13,14,17,18,19,20,22,23,24. Mani, capelli, barba, zaino, cavalcatura e sponda non sono interessati.

Non ci sono parametri.

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.

• 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

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

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

Il risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

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

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

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(5, UO.Self());
    var second = UO.ObjAtLayerEx(4, UO.Self());
    if (Truth(first == 0) || Truth(second == 0))
    {
        return 0;
    }

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

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

Parametri e flusso di esecuzione:

• 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.Undress())))
        {
            return 0;
        }

        dynamic[] layers = new dynamic[checked((int)(16) + 1)];
        layers[0] = 3;
        layers[1] = 4;
        layers[2] = 5;
        layers[3] = 6;
        layers[4] = 7;
        layers[5] = 8;
        layers[6] = 10;
        layers[7] = 12;
        layers[8] = 13;
        layers[9] = 14;
        layers[10] = 17;
        layers[11] = 18;
        layers[12] = 19;
        layers[13] = 20;
        layers[14] = 22;
        layers[15] = 23;
        layers[16] = 24;
        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;
}

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

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.Undress.
• InjectionScript.Runtime.InjectionApiUO.Unequip: Unequip(dressLayers, "Clothing removed.").

Codice interno di implementazione; non è uno script autonomo.

public int Undress()

            => Unequip(dressLayers, "Clothing removed.");

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

int UO.Unequip(object? layer);

Rimuove il suo oggetto dallo strato specificato nel suo zaino.

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

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.

• 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

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

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

Il risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

var result = UO.Unequip(1);
UO.Print("Unequip: " + Convert.ToString(result));

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

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);
    var firstOk = UO.Unequip(1);
    var secondOk = UO.Unequip(2);
    return firstOk != 0 && secondOk != 0;
    return null;
}

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

Parametri e flusso di esecuzione:

• 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 = UO.ObjAtLayerEx(1, UO.Self());
        return ChangeAndConfirm(1, item);
        return null;
    }

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

        if (Truth(UO.ObjAtLayerEx(layer, UO.Self()) != item))
        {
            return 0;
        }

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

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

            UO.Wait(100);
        }

        return 0;
    }

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

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

Parametri: layer (Any/String)

Risultato: int / Any.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "unequip":

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

Parametri: layer (Any/String)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

public int Unequip(string layer) => bridge.Unequip(ConvertLayer(layer));

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

dynamic UO.UnequipItems(object? items);

Ripone nello zaino gli oggetti personali elencati. ID dell'oggetto di qualcun altro non rimuove il tuo oggetto dallo stesso livello.

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

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.

• 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

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

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

Il risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

object? result = UO.UnequipItems(UO.ObjAtLayerEx(1, "self"));
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

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

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);
    dynamic[] items = new dynamic[checked((int)(1) + 1)];
    items[0] = first;
    items[1] = second;
    return UO.UnequipItems(items);
    return null;
}

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

Parametri e flusso di esecuzione:

• 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.ObjAtLayerEx(layer, UO.Self()) != item))
        {
            return 0;
        }

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

        for (int attempt = (int)(1); attempt <= 20; attempt += (int)(1))
        {
            if (Truth(UO.ObjAtLayerEx(layer, UO.Self()) == 0))
            {
                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;
}

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

Parametri: items (Any)

Risultato: dynamic / Any.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "unequipitems":

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

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

void UO.UnsetArm(object? name);

Rimuove una voce per un set di armi con nome senza disarmare il personaggio.

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

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.

• 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.
• La cancellazione ha effetto solo sulla voce del nome selezionato. Gli oggetti rimangono sul personaggio, altri nomi e altri tipi di set non vengono influenzati. È accettabile cancellare nuovamente una voce mancante. UnsetDress e UnsetArm hanno un nome obbligatorio.
• UO.SetDress · UO.Dress · UO.DressSavedSet · UO.SetArm · UO.Arm · UO.DressSpeed
• In un normale host client, questi dati di stato vengono presi dal gestore GetPersistentState e sono comuni a script/chat/macro dello stesso mondo/profilo e non appartengono a uno script. Un altro processo o un InjectionRuntimeState apparentemente separato ha uno stato diverso. Caricare/cancellare un profilo può sostituirlo; salvati serial vengono ancora confrontati con il mondo caricato.

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

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

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

UO.Print("Calling UO.UnsetArm");
UO.UnsetArm("battle");

Parametri e flusso di esecuzione:

• Viene eliminata solo la voce specificata. I vestiti/armi non possono essere rimossi.

UO.UnsetArm("battle");

Parametri e flusso di esecuzione:

• I nomi viaggio e battaglia vengono cancellati separatamente. Viene mantenuto lo stesso nome di un diverso tipo di set.

return  RunScenario();
 object? RunScenario()
{
    UO.UnsetArm("travel");
    UO.UnsetArm("battle");
    return null;
}

Parametri e flusso di esecuzione:

• CleanupSets è una procedura completamente dichiarata per ripulire due nomi propri. il prefisso genera nomi di voci, non percorsi di file.

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()
    {
        CleanupSets("mine_");
        return null;
    }

    void CleanupSets(dynamic prefix)
    {
        UO.UnsetArm(prefix + "travel");
        UO.UnsetArm(prefix + "battle");
    }
}

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

Parametri: name (String)

Risultato: void / Unit.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.UnsetArm.
• InjectionScript.Runtime.State.RuntimeDictionary.Remove: armSets.Remove(name).
• InjectionScript.Runtime.InjectionApiUO.SystemMessage: SystemMessage("Arm set removed.").

Codice interno di implementazione; non è uno script autonomo.

public void UnsetArm(string name)

        {

            armSets.Remove(name);

            SystemMessage("Arm set removed.");

        }

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

void UO.UnsetDress(object? name);

Elimina una voce per un set di vestiti con nome senza rimuovere gli articoli.

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

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.

• 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.
• La cancellazione ha effetto solo sulla voce del nome selezionato. Gli oggetti rimangono sul personaggio, altri nomi e altri tipi di set non vengono influenzati. È accettabile cancellare nuovamente una voce mancante. UnsetDress e UnsetArm hanno un nome obbligatorio.
• UO.SetDress · UO.Dress · UO.DressSavedSet · UO.SetArm · UO.Arm · UO.DressSpeed
• In un normale host client, questi dati di stato vengono presi dal gestore GetPersistentState e sono comuni a script/chat/macro dello stesso mondo/profilo e non appartengono a uno script. Un altro processo o un InjectionRuntimeState apparentemente separato ha uno stato diverso. Caricare/cancellare un profilo può sostituirlo; salvati serial vengono ancora confrontati con il mondo caricato.

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

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

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

UO.Print("Calling UO.UnsetDress");
UO.UnsetDress("travel");

Parametri e flusso di esecuzione:

• Viene eliminata solo la voce specificata. I vestiti/armi non possono essere rimossi.

UO.UnsetDress("travel");

Parametri e flusso di esecuzione:

• I nomi viaggio e battaglia vengono cancellati separatamente. Viene mantenuto lo stesso nome di un diverso tipo di set.

return  RunScenario();
 object? RunScenario()
{
    UO.UnsetDress("travel");
    UO.UnsetDress("battle");
    return null;
}

Parametri e flusso di esecuzione:

• CleanupSets è una procedura completamente dichiarata per ripulire due nomi propri. il prefisso genera nomi di voci, non percorsi di file.

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()
    {
        CleanupSets("mine_");
        return null;
    }

    void CleanupSets(dynamic prefix)
    {
        UO.UnsetDress(prefix + "travel");
        UO.UnsetDress(prefix + "battle");
    }
}

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

Parametri: name (String)

Risultato: void / Unit.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.UnsetDress.
• InjectionScript.Runtime.State.RuntimeDictionary.Remove: dressSets.Remove(name).
• InjectionScript.Runtime.InjectionApiUO.SystemMessage: SystemMessage("Dress set removed.").

Codice interno di implementazione; non è uno script autonomo.

public void UnsetDress(string name)

        {

            dressSets.Remove(name);

            SystemMessage("Dress set removed.");

        }

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

void UO.UseOtherPaperdollScroll(object? objID);

Utilizza il serial specificato tramite bridge.UseObject, solitamente aprendo la bambola di carta del personaggio.

• objID — Oggetto seriale/ID: int, stringa numerica/esadecimale o alias stabilito, ad esempio "lasttarget". Questo non è graphic/type. Controllare l'oggetto caricato prima di agire.

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

• ObjID si riferisce al carattere, non al pulsante di scorrimento ID. La chiamata non legge la struttura del paperdoll e non attende che si apra.
• Bridge invia la richiesta sullo streaming del gioco. Si applicano le regole del server; Non è prevista l'attesa di conferma.

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

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

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

UO.Print("Calling UO.UseOtherPaperdollScroll");
UO.UseOtherPaperdollScroll(UO.GetSerial("lasttarget"));

Parametri e flusso di esecuzione:

• Utilizza il serial specificato tramite bridge.UseObject, solitamente aprendo la bambola di carta del personaggio.

var id = UO.GetSerial("lasttarget");
if (Truth(UO.Exists(id)))
{
    UO.UseOtherPaperdollScroll(id);
}

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

Parametri e flusso di esecuzione:

• ObjID si riferisce al carattere, non al pulsante di scorrimento ID. La chiamata non legge la struttura del paperdoll e non attende che si apra.

return  RunScenario();
 object? RunScenario()
{
    var id = UO.GetSerial("self");
    if (Truth(UO.Exists(id)))
    {
        UO.UseOtherPaperdollScroll(id);
    }

    return null;
}

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

Parametri e flusso di esecuzione:

• Bridge invia la richiesta sullo streaming del gioco. Si applicano le regole del server; Non è prevista l'attesa di conferma.

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()
    {
        ApplyToLoaded(UO.GetSerial("lasttarget"));
        return null;
    }

    void ApplyToLoaded(dynamic id)
    {
        if (Truth(UO.Exists(id)))
        {
            UO.UseOtherPaperdollScroll(id);
        }
    }

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

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

Parametri: objID (Any)

Risultato: void / Unit.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "useotherpaperdollscroll": bridge.UseObject(Arg(0)); return InjectionValue.Unit;

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

void UO.UseSelfPaperdollScroll();

Utilizza il personaggio corrente, solitamente aprendo una bambola di carta.

Non ci sono parametri.

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

• ExecuteClientApiCompatibility chiama bridge.UseObject(bridge.Self). Non è prevista alcuna lettura o clic separato dell'elemento paperdoll; questa è la normale richiesta UseObject per self.
• Negli esempi, UO.Wait specifica solo una pausa nello script; la fine della pausa non dimostra che il server abbia completato la richiesta.

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

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

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

UO.Print("Calling UO.UseSelfPaperdollScroll");
UO.UseSelfPaperdollScroll();

Parametri e flusso di esecuzione:

• Utilizza il personaggio corrente, solitamente aprendo una bambola di carta.

UO.UseSelfPaperdollScroll();

Parametri e flusso di esecuzione:

• ExecuteClientApiCompatibility chiama bridge.UseObject(bridge.Self). Non è prevista alcuna lettura o clic separato dell'elemento paperdoll; questa è la normale richiesta UseObject per self.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Self() != 0))
    {
        UO.UseSelfPaperdollScroll();
    }

    return null;
}

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

Parametri e flusso di esecuzione:

• Negli esempi, UO.Wait specifica solo una pausa nello script; la fine della pausa non dimostra che il server abbia completato la richiesta.

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

     public object? RunScenario()
    {
        UO.UseSelfPaperdollScroll();
        UO.Wait(500);
        UO.Print(UO.Name());
        return null;
    }
}

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

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.UseObject: bridge.UseObject(bridge.Self).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self: bridge.Self.

Codice interno di implementazione; non è uno script autonomo.

case "useselfpaperdollscroll": bridge.UseObject(bridge.Self); return InjectionValue.Unit;

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

dynamic UO.WearItem(object? layer, object? objID);

Equipaggia l'oggetto selezionato sul livello numerico del tuo personaggio.

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

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.

• 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

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

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

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

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

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.WearItem(1, first);
    var secondOk = UO.WearItem(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;

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

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

Parametri: layer (Any), objID (Any)

Risultato: dynamic / Any.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "wearitem": return new InjectionValue(bridge.Equip(Arg(0), Arg(1)));

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

int UO.Weight();

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

Non ci sono parametri.

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

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

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

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

Il risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

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

Parametri e flusso di esecuzione:

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

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

Parametri e flusso di esecuzione:

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

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

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

Parametri e flusso di esecuzione:

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

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

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

        return null;
    }

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

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

        return extra <= maximum - current;
    }

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

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

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "weight": return new InjectionValue(bridge.Weight);