Skip to content

IT UO Topic containers

Jump to bottom
Codex edited this page Oct 12, 2026 · 4 revisions

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

Contenitori

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

Leggi il contenuto, apri e seleziona il contenitore di destinazione. Un contenitore chiuso o non ancora caricato non fornisce al cliente un elenco completo degli articoli.

Sezioni

Argomento Comandi e spiegazioni
Backpack UO.Backpack
Bank UO.ObjAtLayerEx · UO.OpenContainer
OpenContainer UO.OpenContainer
LastContainer UO.LastContainer
ContainerOf UO.ContainerOf · UO.GetParent
IsContainer UO.IsContainer
Contenitori nidificati UO.GetContent · UO.FindTypeEx · UO.FindTypesArrayEx
Receiving Container UO.SetReceivingContainer · UO.UnsetReceivingContainer
Catch Bag UO.SetCatchBag · UO.UnsetCatchBag
Container Transfers UO.MoveItem · UO.MoveItems · UO.MassMove · UO.EmptyContainer

Tutti i comandi del tema

Backpack / Ground

UO.Backpack · UO.Ground

OpenContainer

UO.OpenContainer

LastContainer

UO.LastContainer

ContainerOf

UO.ContainerOf · UO.GetParent · UO.ContainerOff

IsContainer

UO.IsContainer

Contenitori nidificati

UO.GetContent

Contenitore ricevente

UO.SetReceivingContainer · UO.UnsetReceivingContainer

Borsa da cattura

UO.SetCatchBag · UO.UnsetCatchBag

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

Parametri, risultato e tutti gli scenari

UO.OpenContainer("lasttarget");

UO.EmptyContainer

Parametri, risultato e tutti gli scenari

UO.Print("Select a chest or corpse");
var sent = UO.EmptyContainer(350);
if (Truth(sent == 0))
{
    UO.Print("Cancelled, empty, unavailable, or a transfer failed");
}

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

Riferimento completo dei comandi

UO.Backpack

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

Firme C#

int UO.Backpack();

Restituisce il ID dello zaino equipaggiato del personaggio attuale.

Parametri

Non ci sono parametri.

Valore restituito

int - serial/ID, non graphic/type, livello, numero di elementi o bool. 0—non esiste alcun oggetto corrente. Tutti i bit 32 serial vengono salvati; controlla != 0, non == true o > 0. Il risultato salvato non viene aggiornato automaticamente. Cerca un elemento non eliminato sul layer Backpack del Player corrente. Nessun giocatore/giocatore distrutto, nessuno zaino o borsa rimossa - 0. Restituisce il contenitore, non il contenuto; non crea una nuova borsa.

Comportamento

  • Non ci sono parametri. Legge i dati locali tramite Invoke sullo streaming del gioco; l'annullamento dello script interrompe l'attesa per quel thread. Non invia il pacco, non apre il contenitore/destinazione e non trasferisce l'oggetto.
  • Il self/backpack integrato senza parentesi viene letto di nuovo a meno che non venga sovrascritto da una variabile di script. I nomi delle stringhe vengono elaborati dal comando di ricezione. Nella destinazione del trasporto, "self" indica lo zaino e UO.Self() restituisce serial del personaggio. Per il contenitore ID, utilizzare UO.Backpack() esplicitamente.
  • World.Clear rimuove il giocatore; le letture successive producono 0. Entrare nel mondo o cambiare la borsa equipaggiata può cambiare ID. Le letture individuali non sono atomiche. Un valore diverso da zero ID non dimostra la connessione, la risoluzione del server o il caricamento del contenuto.

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

1. Leggi e genera ID - script diretto

Parametri e flusso di esecuzione:

  • id memorizza il risultato di una chiamata; HEX formatta serial per il registro. L'esempio non seleziona né utilizza nulla.
var id = UO.Backpack();
UO.Print("ID: " + Hex(id));

string Hex(object? value) => Convert.ToInt64(value).ToString("X");

2. Rileva modifica ID - Funzione script

Parametri e flusso di esecuzione:

  • prima/dopo vengono letti ad intervalli di 250 ms. UO.Wait aggiunto solo ad esempio. Uguaglianza significa finale identico ID; le modifiche intermedie potrebbero non essere perse.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.Backpack();
    await Delay(250);
    var after = UO.Backpack();
    if (Truth(before != after))
    {
        UO.Print("ID changed: " + Hex(after));
    }

    return null;
}

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

3. Funzione completa IsOwnSerial - classe di script

Parametri e flusso di esecuzione:

  • candidato - salvato ID LastTarget. IsOwnSerial(candidato) prende uno serial e restituisce bool: true per l'attuale proprio diverso da zero ID, altrimenti false. La definizione della funzione è riportata integralmente; l'obiettivo non cambia
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 candidate = UO.LastTarget();
        if (Truth(Truth(IsOwnSerial(candidate)) == true))
        {
            UO.Print("Own object selected");
        }
        else
        {
            UO.Print("Different object or no own object");
        }

        return null;
    }

    dynamic IsOwnSerial(dynamic candidate)
    {
        var current = UO.Backpack();
        return Truth(current != 0) && Truth(current == candidate);
    }

    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.Backpack() — UO.Backpack()

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "backpack": return new InjectionValue(bridge.Backpack);

UO.ContainerOf

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

Firme C#

string UO.ContainerOf(object? name);

Legge il genitore immediato dell'elemento.

Parametri

  • name — Seriale/ID di un oggetto specifico: int, stringa decimale/esadecimale o set alias self, backpack, lasttarget, lastobject o nome AddObject. Questo non è graphic/type.

Valore restituito

string della forma "0x40001234" - serial del proprietario del contenitore/carattere. Per un oggetto a terra è "0x00000000" o "0xFFFFFFFF". Per nome/oggetto sconosciuto o cellulare - "0x00000000". Non è il graphic del contenitore, non il ID dell'oggetto stesso e non il proprietario principale del sacchetto nidificato.

Comportamento

  • Viene letto il campo Contenitore di un elemento locale, senza attraversamento ricorsivo e chiamando il server. Controlla Exists prima di interpretare un risultato nullo. Ground utilizza due rappresentazioni valide.

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

1. Scopri il contenitore di un oggetto: script diretto

Parametri e flusso di esecuzione:

  • l'elemento è serial dello stack trovato. type=0x0EED viene trasmesso solo da FindType.
  • parent denota lo zaino vero e proprio, non il carattere che contiene lo zaino.
var item = UO.FindType(0x0EED, -1, "backpack");
if (Truth(item != ""))
{
    var parent = UO.ContainerOf(item);
    UO.Print(Convert.ToString(parent));
}

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

2. Scopri il proprietario dello zaino - funzione script

Parametri e flusso di esecuzione:

  • L'argomento è lo zaino stesso.
  • Il genitore dello zaino equipaggiato sarà il serial del personaggio.
return  RunScenario();
 object? RunScenario()
{
    var bag = UO.GetSerial("backpack");
    if (Truth(UO.Exists(bag)))
    {
        UO.Print(Convert.ToString(UO.ContainerOf(bag)));
    }

    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. Controlla l'oggetto a terra - Classe di script

Parametri e flusso di esecuzione:

  • GetContent("ground") fornisce ID oggetti all'esterno dei contenitori.
  • Entrambe le rappresentazioni della terra sono valide. Un genitore null senza Exists non è sufficiente per dedurre la posizione di un elemento.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var items = UO.GetContent("ground");
        if (Truth(ArrayLength(items) > 0))
        {
            var item = items[0];
            if (Truth(UO.Exists(item)))
            {
                UO.Print(Convert.ToString(UO.ContainerOf(item)));
            }
        }

        return null;
    }

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

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.ContainerOf(name) — UO.ContainerOf(Any)

Parametri: name (Any)

Risultato: string / String.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public string ContainerOf(InjectionValue name)

        {

            if (TryGetObject(name, out int id))

            {

                var containerId = bridge.ContainerOf(id);

                if (containerId < 0)

                    return "0xFFFFFFFF";



                return $"0x{containerId:X8}";

            }



            return "0x00000000";

        }

UO.ContainerOff

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

Firme C#

void UO.ContainerOff();

Reimposta il contenitore di runtime di ricezione designato.

Parametri

Non ci sono parametri.

Valore restituito

void: nessun valore restituito.

Comportamento

  • Chiama UnsetReceivingContainer e scrive State.ReceivingContainer=0. Le seguenti operazioni Grab senza un'assegnazione esplicita utilizzano lo zaino, se disponibile. Gli elementi non si spostano e la finestra del contenitore non si chiude.

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

1. Reimposta assegnazione - script diretto

Parametri e flusso di esecuzione:

  • Lo stato ReceivingContainer diventa 0.
UO.ContainerOff();

2. Reset dopo l'assegnazione - funzione script

Parametri e flusso di esecuzione:

  • L'incarico è stato cancellato; l'azione non sposta il contenuto.
return  RunScenario();
 object? RunScenario()
{
    UO.SetReceivingContainer("backpack");
    UO.ContainerOff();
    return null;
}

3. Reimposta - Classe script

Parametri e flusso di esecuzione:

  • Lo stato nullo consente il ripristino ripetuto.
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.ContainerOff();
        UO.ContainerOff();
        return null;
    }
}

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.ContainerOff() — UO.ContainerOff()

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public void UnsetReceivingContainer() => bridge.UnsetReceivingContainer();

UO.GetContent

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

Firme C#

dynamic UO.GetContent(object? id);

Legge il contenuto diretto di un contenitore o di oggetti caricati a terra.

Parametri

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

Valore restituito

Array - serial of each direct child. Per ground/0 - articoli fuori dai contenitori; Vengono presi in considerazione entrambi i normali segni al suolo 0 e 0xFFFFFFFF. Senza voci, viene restituito un Array vuoto. L'elenco contiene ID, non type e nessun livello.

Comportamento

  • Vengono letti i dati già scaricati dal client. Il comando non apre il contenitore, non sposta elementi né scarica oggetti dall'intero server.
  • Array - array con indici a partire da 0. Salvalo in var, controlla ArrayLength prima di accedere. Gli elementi potrebbero scomparire dal mondo dopo aver scattato una foto: controlla Exists(serial) prima di agire.
  • Non è previsto l'attraversamento ricorsivo di sacchetti annidati, l'ordinamento della distanza, il filtro Ignore o FindDistance/FindVertical. La normale istantanea FindType rimane invariata.
  • Uno scrigno non aperto può apparire vuoto: l'assenza dei dati ricevuti non dimostra che il server sia vuoto. Per prima cosa utilizzare il contenitore aperto e attendere il suo contenuto.

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

1. Ottieni la dimensione dell'elenco: script diretto

Parametri e flusso di esecuzione:

  • ID="backpack" - zaino del personaggio attuale, solo oggetti nidificati diretti.
  • Lunghezza - numero di record/ID. Questo non è l'importo dell'importo in pile. L'elenco vuoto dà 0.
var items = UO.GetContent("backpack");
UO.Print(Convert.ToString(ArrayLength(items)));

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

2. Attraversa tutto trovato ID - funzione script

Parametri e flusso di esecuzione:

  • ID="backpack" - zaino del personaggio attuale, solo oggetti nidificati diretti.
  • elementi[i] — numerico serial. Hex viene utilizzato solo per l'output. Il ciclo non accede all'ultimo indice.
return  RunScenario();
 object? RunScenario()
{
    var items = UO.GetContent("backpack");
    var i = 0;
    while (Truth(i < ArrayLength(items)))
    {
        UO.Print("0x" + Hex(items[i]));
        i = i + 1;
    }

    return null;
}

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

3. Controlla il primo record prima di leggere - Classe di script

Parametri e flusso di esecuzione:

  • ID="backpack" - zaino del personaggio attuale, solo oggetti nidificati diretti.
  • Vengono controllate due cose diverse: il record nell'istantanea e l'esistenza dell'oggetto adesso. L'ordine senza una cernita esplicita non significa vicinanza.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

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

        return null;
    }

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

4. Ottieni tutti gli oggetti terrestri scaricati: script diretto

Parametri e flusso di esecuzione:

  • ID="ground" seleziona esplicitamente il terreno. NPC/giocatori non sono inclusi in questo elenco.
  • Il raggio di ricerca qui non è limitato a FindDistance. Per il filtro type e la distanza c'è GetWorldItems(type,colore,distanza).
var groundItems = UO.GetContent("ground");
UO.Print(Convert.ToString(ArrayLength(groundItems)));

int ArrayLength(object? value) => value is System.Array array ? array.Length : 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.GetContent(id) — UO.GetContent(Any)

Parametri: id (Any)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "getcontent":

                case "getequipment":

                {

                    InjectionValue selection = arguments[0];

                    bool ground = false, explicitZero;

                    int container;

                    if (selection.Kind == InjectionValueKind.String)

                    {

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

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

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

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

                            ? bridge.Backpack : GetObject(text);

                    }

                    else

                    {

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

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

                        container = Arg(0);

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

                    }

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

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

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

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

                    int[] items = equipment

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

                        : bridge.GetContent(container);

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

                }

UO.GetParent

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

Firme C#

dynamic UO.GetParent(object? objID);

Legge il genitore immediato dell'elemento.

Parametri

  • objID — Seriale/ID di un oggetto specifico: int, stringa decimale/esadecimale o set alias self, backpack, lasttarget, lastobject o nome AddObject. Questo non è graphic/type.

Valore restituito

int - serial proprietario del contenitore/carattere. Per un oggetto a terra, è 0 o -1 (bit 0xFFFFFFFF), a seconda dell'immissione del cliente. Per un oggetto o cellulare sconosciuto - 0. Non è il graphic del contenitore, non il ID dell'oggetto stesso e non il proprietario principale del sacchetto nidificato.

Comportamento

  • Viene letto il campo Contenitore di un elemento locale, senza attraversamento ricorsivo e chiamando il server. Controlla Exists prima di interpretare un risultato nullo. Ground utilizza due rappresentazioni valide.

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

1. Scopri il contenitore di un oggetto: script diretto

Parametri e flusso di esecuzione:

  • l'elemento è serial dello stack trovato. type=0x0EED viene trasmesso solo da FindType.
  • parent denota lo zaino vero e proprio, non il carattere che contiene lo zaino.
var item = UO.FindType(0x0EED, -1, "backpack");
if (Truth(item != ""))
{
    var parent = UO.GetParent(item);
    UO.Print(Convert.ToString(parent));
}

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

2. Scopri il proprietario dello zaino - funzione script

Parametri e flusso di esecuzione:

  • L'argomento è lo zaino stesso.
  • Il genitore dello zaino equipaggiato sarà il serial del personaggio.
return  RunScenario();
 object? RunScenario()
{
    var bag = UO.GetSerial("backpack");
    if (Truth(UO.Exists(bag)))
    {
        UO.Print(Convert.ToString(UO.GetParent(bag)));
    }

    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. Controlla l'oggetto a terra - Classe di script

Parametri e flusso di esecuzione:

  • GetContent("ground") fornisce ID oggetti all'esterno dei contenitori.
  • Entrambe le rappresentazioni della terra sono valide. Un genitore null senza Exists non è sufficiente per dedurre la posizione di un elemento.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var items = UO.GetContent("ground");
        if (Truth(ArrayLength(items) > 0))
        {
            var item = items[0];
            if (Truth(UO.Exists(item)))
            {
                UO.Print(Convert.ToString(UO.GetParent(item)));
            }
        }

        return null;
    }

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

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.GetParent(objID) — UO.GetParent(Any)

Parametri: objID (Any)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "getparent": return new InjectionValue(bridge.ContainerOf(Arg(0)));

UO.Ground

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

Firme C#

int UO.Ground();

Restituisce un designatore di terreno speciale per il parametro del contenitore di ricerca o la destinazione del trasferimento.

Parametri

Non ci sono parametri.

Valore restituito

int, sempre 0. Questo zero è un designatore di terreno valido, non false, non un errore di ricerca, non l'elemento ID, graphic, numero di mappa o coordinata. Non selezionare Ground() come segno di successo; controlla il risultato della ricerca o del trasferimento a cui è stato passato questo valore.

Comportamento

  • Non ci sono parametri. La stessa chiamata Ground() non cerca nulla, non sposta nulla, non apre la destinazione, non invia pacchetti e non modifica i risultati della ricerca precedente. Prima di entrare in gioco restituisce anche 0.
  • Invia i comandi FindType, FindList, Count, FindTypeEx, FindTypesArrayEx, CountEx o MoveItem alla posizione del contenitore/destinazione. La ricerca vede gli oggetti del mondo caricati, ma non carica le celle distanti. Per il trasferimento a terra, X/Y/Z sono le coordinate mondiali, non i pixel della finestra del contenitore.
  • FindType(type, colore) appare ancora nell'inventario: il secondo parametro è colore. Per la terra, scrivi FindType(type, colore, UO.Ground()). Nel vecchio compact FindType/MoveItem il numero -1 indica l'inventario; in compatibile FindTypeEx/FindTypesArrayEx/CountEx - 1 è consentito anche come terra. Utilizzare UO.Ground() o il nome esplicito ground, non trasferire designazioni numeriche tra comandi diversi senza verifica.
  • Le differenze di notazione tra i comandi e gli esempi precedenti descrivono questo client.

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

1. Leggi il simbolo della terra - scrittura diretta

Parametri e flusso di esecuzione:

  • la destinazione riceve int 0, Print emette questo numero. La chiamata in sé non butta via nulla.
var destination = UO.Ground();
UO.Print(Convert.ToString(destination));

2. Trova una pila d'oro a terra - funzione script

Parametri e flusso di esecuzione:

  • 0x0EED - grafica dorata; il secondo -1 significa qualsiasi hue. Ground() imposta una ricerca nel mondo, false disabilita la ricorsione del contenitore. FindTypeEx restituisce uno serial o 0 se non ci sono risultati. != 0 controlla questo serial. Vengono utilizzati l'attuale FindDistance/FindVertical e l'elenco Ignore.
return  RunScenario();
 object? RunScenario()
{
    var id = UO.FindTypeEx(0x0EED, -1, UO.Ground(), false);
    if (Truth(id != 0))
    {
        UO.Print(Hex(id));
    }
    else
    {
        UO.Print("0");
    }

    return null;
}

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

3. Funzione completa per trovare due grafici sulla terra - classe di script

Parametri e flusso di esecuzione:

  • FindGroundTypes(firstType, secondType, raggio, altezza) cerca oro 0x0EED e perla nera 0x0F7A con raggio=5 e altezza=10. dichiarando la variabile tipi[1] si creano due celle; colori[0] e contenitori[0] - uno ciascuno. L'intero stack conta come un risultato; tipi/colori sono alternativi, i contenitori che si intersecano non duplicano ID. La funzione restituisce l'array salvato serial; Infine ripristina entrambi i limiti. Uscite principali ogni ID. Il codice funzione è riportato per intero.
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 ids = FindGroundTypes(0x0EED, 0x0F7A, 5, 10);
        foreach (var id in ids)
        {
            UO.Print(Hex(id));
        }

        return null;
    }

    dynamic FindGroundTypes(dynamic firstType, dynamic secondType, dynamic radius, dynamic height)
    {
        var oldDistance = UO.FindDistance();
        var oldVertical = UO.FindVertical();
        dynamic[] types = new dynamic[checked((int)(1) + 1)];
        types[0] = firstType;
        types[1] = secondType;
        dynamic[] colors = new dynamic[checked((int)(0) + 1)];
        colors[0] = -1;
        dynamic[] containers = new dynamic[checked((int)(0) + 1)];
        containers[0] = UO.Ground();
        try
        {
            UO.FindDistance(radius);
            UO.FindVertical(height);
            UO.FindTypesArrayEx(types, colors, containers, false);
            return UO.GetFoundItems();
        }
        finally
        {
            UO.FindDistance(oldDistance);
            UO.FindVertical(oldVertical);
        }
    }

    string Hex(object? value) => Convert.ToInt64(value).ToString("X");
}

4. Sposta un oggetto conosciuto nella cella di un personaggio - script diretto

Parametri e flusso di esecuzione:

  • Sostituisci 0x40001001 con serial di un articolo disponibile. IsObjectExists controlla innanzitutto l'oggetto caricato. MoveItem(oggetto, importo, destinazione, X, Y, Z): importo=0 - l'intero stack, Ground() - terra, GetX/GetY/GetZ - la cella del mondo del personaggio. il risultato è 1 se il cliente ha accettato la richiesta di trasferimento, altrimenti 0. Questo è il risultato di MoveItem, non Ground(), e non una conferma di consegna dal server.
var item = 0x40001001;
if (Truth(UO.IsObjectExists(item)))
{
    var result = UO.MoveItem(item, 0, UO.Ground(), UO.GetX("self"), UO.GetY("self"), UO.GetZ("self"));
}

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.Ground() — UO.Ground()

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "ground": return new InjectionValue(0);

UO.IsContainer

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

Firme C#

int UO.IsContainer(object? objID);

Controlla il flag Contenitore nei Tiledata del tipo grafico dell'oggetto caricato.

Parametri

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

Valore restituito

int 1 - un articolo noto ha un attributo contenitore nei suoi dati graphic. int 0 - non esiste tale segno, l'oggetto è mobile, sconosciuto o cancellato. Questo non è il numero di cose nel contenitore, non è un segno di una gomma aperta e non è una conferma dell'accesso al contenuto.

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

  • Viene letto il modello client locale; Non ci sono richieste al server, nessuna attesa o spostamento.
  • Il risultato si riferisce al momento della lettura. Dopo UO.Wait o altra azione, l'oggetto e i suoi flag potrebbero cambiare.

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

1. Controlla l'ultimo elemento utilizzato: script diretto

Parametri e flusso di esecuzione:

  • item è il serial dell'oggetto lastobject, non il suo type.
  • Il comando legge solo l'attributo contenitore e non lo apre.
var item = UO.GetSerial("lastobject");
if (Truth(UO.IsContainer(item)))
{
    UO.Print("Known container: " + item);
}
else
{
    UO.Print("Not a known container");
}

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

2. Seleziona il contenitore prima della ricerca - funzione script

Parametri e flusso di esecuzione:

  • la borsa deve essere selezionata in anticipo e il contenuto deve essere noto al cliente.
  • FindType riceve type oro, qualsiasi contenitore hue e serial. Un risultato vuoto non dimostra che il contenitore del server sia vuoto.
return  RunScenario();
 object? RunScenario()
{
    var bag = UO.GetSerial("lasttarget");
    if (Truth(UO.IsContainer(bag)))
    {
        var found = UO.FindType(0x0EED, -1, bag);
        UO.Print("Known gold item: " + found);
    }

    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. Verificare separatamente la presenza e la classificazione - classe scenario

Parametri e flusso di esecuzione:

  • Exists e IsContainer rispondono a domande diverse sullo stesso serial.
  • Qualora i Tiledata non siano idonei o non siano ancora disponibili, la classificazione potrebbe differire da quanto previsto; non usarlo come controllo per i diritti del torace.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var bag = UO.GetSerial("backpack");
        var exists = UO.Exists(bag);
        var container = UO.IsContainer(bag);
        UO.Print("Loaded: " + Convert.ToString(exists));
        UO.Print("Container flag: " + Convert.ToString(container));
        return null;
    }
}

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.IsContainer(objID) — UO.IsContainer(Any)

Parametri: objID (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "iscontainer": return new InjectionValue(bridge.IsContainer(Arg(0)));

UO.LastContainer

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

Firme C#

dynamic UO.LastContainer();

Legge serial dell'ultimo contenitore.

Parametri

Non ci sono parametri.

Valore restituito

int — salvato serial; 0 significa che serial non è installato. Non è bool e non graphic/type; un ID diverso da zero potrebbe non esistere più nel mondo.

Comportamento

  • Origine campo: _world.LastContainer. Il comando non seleziona, utilizza o attacca l'oggetto.
  • Legge lo stato locale attuale. Non esiste alcun pacchetto, destinazione o aggiornamento automatico; le singole letture possono vedere stati diversi.

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Legge serial dell'ultimo contenitore.
var id = UO.LastContainer();
UO.Print(Hex(id));

string Hex(object? value) => Convert.ToInt64(value).ToString("X");

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • Origine campo: _world.LastContainer. Il comando non seleziona, utilizza o attacca l'oggetto.
return  RunScenario();
 object? RunScenario()
{
    var id = UO.LastContainer();
    if (Truth(id != 0) && Truth(UO.Exists(id)))
    {
        UO.Print(UO.GetName(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;

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

  • Legge lo stato locale attuale. Non esiste alcun pacchetto, destinazione o aggiornamento automatico; le singole letture possono vedere stati diversi.
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 before = UO.LastContainer();
        UO.Wait(500);
        var after = UO.LastContainer();
        UO.Print(before = after);
        return null;
    }
}

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.LastContainer() — UO.LastContainer()

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "lastcontainer": return new InjectionValue(bridge.GetLastContainer());

UO.OpenContainer

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

Firme C#

void UO.OpenContainer(object? id);
void UO.OpenContainer(object? id, object? timeout);

Richieste di apertura di un contenitore.

Parametri

  • id — Oggetto seriale/ID: int, stringa numerica/esadecimale o alias stabilito, ad esempio "lasttarget". Questo non è graphic/type. Controllare l'oggetto caricato prima di agire.
  • timeout - Opzionale int, millisecondi; l'impostazione predefinita è 0. Un valore negativo non aggiunge anticipazione.

Valore restituito

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

Comportamento

  • Bridge.OpenContainer chiama UseObject(id), quindi UO.Wait(timeout) solo se timeout>0. La pausa è fissa; la presenza/il contenuto del contenitore non vengono controllati.
  • Senza timeout non c'è pausa. La fine della pausa non deve essere considerata come prova che il contenuto sia stato aperto o completamente caricato.

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Richieste di apertura di un contenitore.
UO.OpenContainer("lasttarget");

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • Bridge.OpenContainer chiama UseObject(id), quindi UO.Wait(timeout) solo se timeout>0. La pausa è fissa; la presenza/il contenuto del contenitore non vengono controllati.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Exists("lasttarget")))
    {
        UO.OpenContainer("lasttarget", 1000);
    }

    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. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

  • Senza timeout non c'è pausa. La fine della pausa non deve essere considerata come prova che il contenuto sia stato aperto o completamente caricato.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var id = UO.GetSerial("lasttarget");
        if (Truth(UO.Exists(id)))
        {
            UO.OpenContainer(id, 1000);
            UO.Print(UO.GetName(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;
}

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.OpenContainer(id) — UO.OpenContainer(Any)

Parametri: id (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public void OpenContainer(InjectionValue id) => bridge.OpenContainer(GetObject(id), 0);

UO.OpenContainer(id, timeout) — UO.OpenContainer(Any,Any)

Parametri: id (Any), timeout (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public void OpenContainer(InjectionValue id, InjectionValue timeout) => bridge.OpenContainer(GetObject(id), NumberConversions.ToInt(timeout));

UO.SetCatchBag

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

Firme C#

void UO.SetCatchBag();
void UO.SetCatchBag(object? container);

Parametri

  • container - Numero seriale del contenitore, nome salvato, "backpack" o "my". 0 annulla l'assegnazione. Senza argomenti, viene utilizzato lastobject: l'ultimo oggetto applicato, non reimpostato. Se il nome non si risolve in positivo serial, l'assegnazione viene rimossa. L'installazione stessa non verifica la disponibilità del server e l'idoneità dell'oggetto per la migrazione.

Valore restituito

void: nessun valore restituito. Non puoi usare var result = UO.SetCatchBag(...), se UO.SetCatchBag(...), o aspettarti il ​​numero 1 come conferma. Il movimento effettivo viene eseguito da un comando separato, ad esempio Grab.

Comportamento

  • UO.SetCatchBag() e UO.SetReceivingContainer() hanno valori di forma diversi senza argomenti: il primo accetta lastobject, il secondo reimposta il contenitore.
  • Reset esplicito: UO.UnsetCatchBag(), UO.UnsetReceivingContainer() o UO.SetCatchBag(0). Dopo il ripristino, Grab utilizza il suo zaino senza un incarico separato.
  • L'impostazione serial non significa che il server consentirà il posizionamento dell'elemento lì. Distanza, esistenza e disponibilità vengono verificate durante il trasferimento vero e proprio.
  • 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.

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

1. Assegna esplicitamente il tuo zaino - script diretto

Parametri e flusso di esecuzione:

  • Il parametro del contenitore singolo riceve la stringa "backpack". Il runtime lo consente in serial del tuo zaino.
  • La chiamata viene scritta su una riga separata senza risultato var perché restituisce Unit. Il messaggio Print descrive l'impostazione e non conferma il trasferimento dell'articolo.
var destination = "backpack";
UO.SetCatchBag(destination);
UO.Print("Receiving container: own backpack");

2. Seleziona l'ultimo contenitore utilizzato - funzione script

Parametri e flusso di esecuzione:

  • Questo sovraccarico non ha parametri: internamente viene utilizzato il nome lastobject.
  • Le parentesi vuote non significano reset. Preselezionare il contenitore appropriato semplicemente facendo doppio clic. La disponibilità delle borse per il trasporto effettivo dipende dallo stato attuale del gioco.
return  RunScenario();
 object? RunScenario()
{
    UO.SetCatchBag();
    UO.Print("Destination taken from lastobject");
    return null;
}

3. Imposta un serial specifico e quindi restituisce la destinazione predefinita: classe di script

Parametri e flusso di esecuzione:

  • Nella prima chiamata, container=bag contiene la stringa esadecimale serial. 0x40001234 è un esempio, devi sostituirlo con il tuo valore.
  • Nella seconda chiamata, container=0 ne annulla l'assegnazione. I successivi Grab senza contenitore esplicito utilizzano uno zaino.
  • Il ripristino si trova dopo il blocco di trasporto previsto. L'impostazione e il ripristino non restituiscono un risultato e non spostano gli elementi autonomamente.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var bag = "0x40001234";
        UO.SetCatchBag(bag);
        UO.Print("Configured destination: " + bag);
        UO.SetCatchBag(0);
        UO.Print("Destination reset to the normal backpack fallback");
        return null;
    }
}

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.SetCatchBag() — UO.SetCatchBag()

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "setcatchbag":

                    SetReceivingContainer(arguments.Length > 0 ? arguments[0].ToString() : "lastobject");

                    break;

UO.SetCatchBag(container) — UO.SetCatchBag(Any)

Parametri: container (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "setcatchbag":

                    SetReceivingContainer(arguments.Length > 0 ? arguments[0].ToString() : "lastobject");

                    break;

UO.SetReceivingContainer

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

Firme C#

void UO.SetReceivingContainer();
void UO.SetReceivingContainer(object? id);

Imposta il contenitore di ricezione per il futuro Grab.

Parametri

  • id - Opzionale serial/alias. "my"/"backpack" - zaino attuale. Il positivo ID viene mantenuto senza controllo di esistenza; 0/negativo/nessun argomento cancella l'impostazione.

Valore restituito

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

Comportamento

  • La stringa viene risolta GetObject, ad eccezione dello speciale my/backpack. Bridge.SetReceivingContainer assegna lo Stato.ReceivingContainer. L'elemento non viene trasferito da questa chiamata.
  • Dopo aver ripulito, Grab usa lo zaino senza uno scopo esplicito. Un ID positivo di per sé non conferma che il contenitore sia caricato o accessibile al server.
  • 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.

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Imposta il contenitore di ricezione per il futuro Grab.
UO.SetReceivingContainer("backpack");

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • La stringa viene risolta GetObject, ad eccezione dello speciale my/backpack. Bridge.SetReceivingContainer assegna lo Stato.ReceivingContainer. L'elemento non viene trasferito da questa chiamata.
return  RunScenario();
 object? RunScenario()
{
    UO.SetReceivingContainer();
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

  • Dopo aver ripulito, Grab usa lo zaino senza uno scopo esplicito. Un ID positivo di per sé non conferma che il contenitore sia caricato o accessibile al server.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var bag = UO.GetSerial("lastcontainer");
        if (Truth(UO.IsContainer(bag)))
        {
            UO.SetReceivingContainer(bag);
        }

        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.SetReceivingContainer() — UO.SetReceivingContainer()

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public void SetReceivingContainer() => UnsetReceivingContainer();

UO.SetReceivingContainer(id) — UO.SetReceivingContainer(Integer)

Parametri: id (Integer/String)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public void SetReceivingContainer(int id)

        {

            if (id <= 0)

                bridge.UnsetReceivingContainer();

            else

                bridge.SetReceivingContainer(id);

        }

UO.SetReceivingContainer(id) — UO.SetReceivingContainer(String)

Parametri: id (Integer/String)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public void SetReceivingContainer(string id)

        {

            string name = (id ?? string.Empty).Trim();

            if (name.Equals("my", StringComparison.OrdinalIgnoreCase)

                || name.Equals("backpack", StringComparison.OrdinalIgnoreCase))

            {

                SetReceivingContainer(bridge.Backpack);

                return;

            }

            SetReceivingContainer(GetObject(id));

        }

UO.UnsetCatchBag

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

Firme C#

void UO.UnsetCatchBag();

Cancella il contenitore di ricezione per Grab.

Parametri

Non ci sono parametri.

Valore restituito

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

Comportamento

  • ExecuteLegacyManualAlias chiama UnsetReceivingContainer; il ponte assegna ReceivingContainer=0. Il successivo Grab utilizza uno zaino. Questa non è la rimozione della borsa.
  • Modifica o visualizza solo i dati locali specificati. Questo comando non ha la conferma del server.
  • 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.

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Cancella il contenitore di ricezione per Grab.
UO.UnsetCatchBag();

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • ExecuteLegacyManualAlias chiama UnsetReceivingContainer; il ponte assegna ReceivingContainer=0. Il successivo Grab utilizza uno zaino. Questa non è la rimozione della borsa.
return  RunScenario();
 object? RunScenario()
{
    UO.SetCatchBag("backpack");
    UO.UnsetCatchBag();
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

  • Modifica o visualizza solo i dati locali specificati. Questo comando non ha la conferma del server.
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.UnsetCatchBag();
        UO.Print(UO.Backpack());
        return null;
    }
}

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.UnsetCatchBag() — UO.UnsetCatchBag()

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "unsetcatchbag": UnsetReceivingContainer(); break;

UO.UnsetReceivingContainer

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

Firme C#

void UO.UnsetReceivingContainer();

Cancella il contenitore di ricezione salvato.

Parametri

Non ci sono parametri.

Valore restituito

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

Comportamento

  • UnsetReceivingContainer assegna ReceivingContainer=0. Il successivo Grab utilizza uno zaino senza uno scopo esplicito. Gli articoli non vengono trasferiti.
  • Modifica o visualizza solo i dati locali specificati. Questo comando non ha la conferma del server.
  • 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.

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Cancella il contenitore di ricezione salvato.
UO.UnsetReceivingContainer();

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • UnsetReceivingContainer assegna ReceivingContainer=0. Il successivo Grab utilizza uno zaino senza uno scopo esplicito. Gli articoli non vengono trasferiti.
return  RunScenario();
 object? RunScenario()
{
    UO.SetReceivingContainer("backpack");
    UO.UnsetReceivingContainer();
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

  • Modifica o visualizza solo i dati locali specificati. Questo comando non ha la conferma del server.
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.UnsetReceivingContainer();
        UO.Print(UO.Backpack());
        return null;
    }
}

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.UnsetReceivingContainer() — UO.UnsetReceivingContainer()

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public void UnsetReceivingContainer() => bridge.UnsetReceivingContainer();

ClassicUO — Bad Newbie & C# Scripts IDE

ClassicUO — Bad Newbie & C# Scripts IDE

Clone this wiki locally