Skip to content

IT UO Topic items

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

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

Oggetti

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

Proprietà, uso e trasferimento degli oggetti. Serial seleziona un elemento specifico; type/graphic seleziona la vista. Il trasferimento delle unità impilabili e il numero di articoli trasferiti hanno parametri diversi.

Sezioni

Argomento Comandi e spiegazioni
Item Properties UO.GetSerial · UO.GetType · UO.GetGraphic · UO.GetColor · UO.GetQuantity · UO.GetName · UO.GetTooltip · UO.ContainerOf · UO.GetParent · UO.GetLayer · UO.IsMovable · UO.GetX · UO.GetY · UO.GetZ
Ricerca di elementi UO.FindType · UO.FindTypeEx · UO.FindTypesArrayEx · UO.FindItem · UO.FindAnyType · UO.FindAtCoord · UO.FindList · UO.FindDistance · UO.FindVertical
Utilizzo degli elementi UO.UseObject · UO.UseType · UO.UseFromGround · UO.UseWorldObject · UO.UseItemOnMobile
Moving Elementi UO.Grab · UO.Drag · UO.Drop · UO.MoveItem · UO.MoveItems · UO.MassMove · UO.EmptyContainer
Ground Elementi UO.GetWorldItems · UO.FindType · UO.CountGround · UO.MoveItem
Articoli contenitore UO.GetContent · UO.FindTypeEx · UO.OpenContainer
Articoli falsi/clienti UO.MakeFakeItem · UO.DeleteObject
Dye UO.Dye

Tutti i comandi del tema

Proprietà dell'oggetto

UO.Exists · UO.IsObjectExists · UO.GetSerial · UO.GetType · UO.GetGraphic · UO.GetColor · UO.GetQuantity · UO.Name · UO.GetName · UO.GetAltName · UO.GetTooltip · UO.GetTooltipRec · UO.GetLayer · UO.GetLocked · UO.IsMovable · UO.GetFlags · UO.ReceiveObjectName · UO.UpdateObject

Utilizzo degli oggetti

UO.UseObject · UO.UseType · UO.UseFromGround · UO.UseWorldObject · UO.UseItemOnMobile · UO.ClickOnObject · UO.TicksUse

Moving Articoli

UO.Grab · UO.Drag · UO.DragItem · UO.Drop · UO.DropHere · UO.DropItem · UO.MoveItem · UO.MoveItems · UO.MassMove · UO.EmptyContainer · UO.DropDelay · UO.DropCheckCoord · UO.Picking

Articoli falsi/clienti

UO.MakeFakeItem · UO.DeleteObject

Dye

UO.Dye

Oggetti archiviati

UO.AddObject · UO.AddType · UO.EasyObject · UO.UserObject · UO.LastObject · UO.Forget

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

Parametri, risultato e tutti gli scenari

var ok = UO.MoveItem("loot");
UO.Print("Move request: " + Convert.ToString(ok));

UO.MassMove

Parametri, risultato e tutti gli scenari

UO.MassMove(350, 0);
UO.Print("Drag one sample item to the destination container");

Parti del riferimento

1 · 2

Riferimento completo dei comandi

UO.AddObject

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

Firme C#

void UO.AddObject(object? name);
void UO.AddObject(object? name, object? objectRawId);

Memorizza un oggetto denominato serial per un utilizzo successivo da parte degli script. La forma a due argomenti specifica immediatamente l'oggetto; un argomento attiva la selezione di un oggetto tramite il cursore.

Parametri

  • name è un nome non vuoto con il quale l'oggetto sarà disponibile in fase di runtime.
  • objectRawId - serial o un nome di oggetto già salvato. L'overload con un argomento non accetta questo parametro, ma richiede invece la selezione di un oggetto.

Valore restituito

void. Controllare l'associazione salvata leggendo l'oggetto per nome; la chiamata non restituisce serial.

Comportamento

  • Dati due argomenti, il runtime risolve objectRawId e memorizza serial sotto name. Con un argomento, il client richiede una selezione di oggetto: viene selezionato l'oggetto o mobile, ma non la cella della carta. Prima della selezione viene cancellata la precedente associazione con lo stesso nome; cancellando/perdendo il cursore non lo si ripristina.

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

1. Salva serial di un oggetto conosciuto con un nome conveniente. - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Salva serial di un oggetto conosciuto con un nome conveniente.
UO.AddObject("supplyBox", "0x40012345");

2. Richiedere la selezione di un elemento oppure mobile con il cursore e denominarlo target. - funzione di script

Parametri e flusso di esecuzione:

  • Richiedere la selezione di un elemento oppure mobile con il cursore e denominarlo target.
return  RunScenario();
 object? RunScenario()
{
    UO.AddObject("target");
    return null;
}

3. Salvando nuovamente il nome si sostituisce l'associazione con un nuovo serial. - lezione di sceneggiatura

Parametri e flusso di esecuzione:

  • Salvando nuovamente il nome si sostituisce l'associazione con un nuovo serial.
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 selectedSerial = "0x40012345";
        UO.AddObject("supplyBox", selectedSerial);
        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.AddObject(name) — UO.AddObject(String)

Parametri: name (String)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public void AddObject(string name)

        {

            SystemMessage($"What is {name}");

            bridge.AddObject(name);

        }

UO.AddObject(name, objectRawId) — UO.AddObject(Any,Any)

Parametri: name (Any), objectRawId (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public void AddObject(InjectionValue name, InjectionValue objectRawId) 

            => ObjectChecked(objectRawId, id => AddObject((string)name, id));

UO.AddType

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

Firme C#

void UO.AddType(object? name);
void UO.AddType(object? name, object? @type);

Memorizza un nome descrittivo per l'elemento o il tipo di grafica del corpo mobile. Ad esempio, dopo UO.AddType("bandage", 0x0E21) è possibile cercare o utilizzare bende attraverso il nome "benda" senza ripetere il numerico type su ogni riga. Questo significa impostare un nome → Mappatura grafica, non creare un elemento o ricordare uno specifico ID.

Parametri

  • name - Stringa richiesta tra virgolette: il nome del tuo tipo. Gli spazi sul bordo vengono rimossi, le maiuscole e le minuscole non sono importanti: "Benda" e "benda" sono una voce. Stringa vuota, nome numerico, parola qualsiasi, carattere | e i caratteri di controllo sono vietati. Questo è il valore del parametro, non una nuova variabile o un comando UO: anche le chiamate successive richiedono virgolette.
  • type - Optional int 0..65535: Graphic/type, such as 0x0E21 or 3617. A string with a decimal/hexadecimal number or the name of an already saved type is acceptable; the latter copies its current number, does not create a connection between names. ID of the form 0x40001001, negative number, fraction and unknown name are not accepted. If there is no argument, a selection cursor appears: click on the loaded item, including inside the container, or mobile. La Grafica dell'oggetto selezionato viene salvata; la superficie del terreno e la piastrella statica non sono adatte.

Valore restituito

void - nessun valore restituito. Scrivi su una riga separata, senza risultato var = e senza confronto con true/1. Il comando non restituisce il type, serial selezionato o il flag di successo. Annullando con il mouse viene mantenuta la vecchia voce; se prima non c'era un nome, rimane indefinito. La riga successiva dello script viene eseguita dopo un normale annullamento, quindi non attivare automaticamente l'azione presupponendo che l'utente abbia definitivamente selezionato un nuovo elemento.

Comportamento

  • La forma AddType(nome, type) memorizza il numero immediatamente, senza cursore e senza un'azione di rete. Una ripetizione con lo stesso nome ne sostituisce il tipo. Un valore errato non distrugge la voce precedente. Il modulo AddType(nome) è in attesa di selezione; Esc, sostituendo il cursore con un'altra azione o un bersaglio inappropriato lascia la voce invariata. L'arresto forzato dello script interrompe l'attesa e libera solo il cursore che gli appartiene.
  • I nomi dei tipi sono tenuti separati da AddObject: la stessa parola potrebbe rappresentare type in FindType e serial in UseObject. AddType("supply", 0x0E21) non rende di per sé valido UseObject("supply"). Per un articolo specifico, usa AddObject/GetSerial; per una famiglia di articoli - AddType e parametro type.
  • I nomi vengono risolti nei parametri type FindType (tutti i moduli), FindTypeEx, FindTypesArrayEx, FindList, FindNotoriety, GetWorldItems, UseType, UseFromGround, Count, CountGround, CountEx, EquipT, WaitTargetType, WaitTargetGround e WaitTargetObjectType. Nelle maschere del tipo GetMobiles/FindAnyType/WaitTarget è possibile combinare i nomi tramite | o matrice; le regole della notorietà rimangono separate. Le parole umano/vicino e altri filtri FindMobile non vengono sovrascritti.
  • Viene salvata solo la grafica, nessun colore, quantità, contenitore, nome oggetto, livello o proprietà. Due articoli dello stesso tipo di colori diversi richiedono un colore separato nella ricerca. La voce non conferma che l'elemento esiste attualmente, è disponibile o che il server consentirà l'azione.

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

1. Raccogli una pila d'oro trovata - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • pila_oro - nome; 0x0EED – Grafica oro. FindType: -1 - qualsiasi colore, ground - terra, 2 - raggio di ricerca. Viene restituita la stringa serial o una stringa vuota.
  • MoveItem riceve il serial trovato, 0 per l'intero stack e backpack come destinazione. Questo è uno stack, non tutti gli stack nel raggio. La disponibilità del trasferimento e il risultato effettivo dipendono dal server; la definizione del tipo in sé non contiene nulla.
UO.AddType("gold_stack", 0x0EED);
var item = UO.FindType("gold_stack", -1, "ground", 2);
if (Truth(item == ""))
{
    UO.Print("No loaded gold stack within 2 tiles");
    return null;
}
var moved = UO.MoveItem(item, 0, "backpack");
if (Truth(moved == 0))
{
    UO.Print("Move request failed");
}

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

2. Usa la benda solo quando hai poca salute - funzione script

Parametri e flusso di esecuzione:

  • Il numero di stringa 0x0E21 è memorizzato come int Grafico. Life/MaxHP confronta il carattere HP. FindType cerca ricorsivamente qualsiasi colore nello zaino; -1 a distanza utilizza il comportamento di ricerca standard.
  • self è lo scopo dell'applicazione, bendaggio dopo FindType è una variabile con serial. La coda del bersaglio viene preparata prima di utilizzare l'oggetto. Lo script invia l'utilizzo e non afferma che il trattamento sia già terminato; Le regole del timer/trattamento dipendono dal server.
return  RunScenario();
 object? RunScenario()
{
    UO.AddType("bandage", "0x0E21");
    if (Truth(UO.Life() >= UO.MaxHP()))
    {
        return null;
    }

    var bandage = UO.FindType("bandage", -1, "backpack", -1, true);
    if (Truth(bandage == ""))
    {
        UO.Print("No loaded bandages in backpack");
        return null;
    }

    UO.WaitTargetObject("self");
    UO.UseObject(bandage);
    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. Assegna il tuo strumento al mouse, applicalo come una procedura separata - classe di script

Parametri e flusso di esecuzione:

  • Main contiene solo il nome, quindi si apre il cursore. Viene salvato il tipo di strumento, non il suo ID e non il suo colore. UseSavedTool è una normale procedura autonoma C#, non un comando integrato.
  • UseType cerca un'istanza di un tipo salvato di qualsiasi colore nello zaino e la utilizza; restituisce int serial o 0 se mancante. Se il nome non è mai stato definito, si tratta di un errore di argomento, non del risultato di 0. Dopo l'annullamento dell'assegnazione, Main non chiama UseSavedTool.
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.AddType("my_tool");
        return null;
    }

    void UseSavedTool()
    {
        var used = UO.UseType("my_tool", -1, "backpack");
        if (Truth(used == 0))
        {
            UO.Print("No matching loaded tool in backpack");
        }
    }

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

Parametri: name (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "addtype":

                    AddType(arguments);

                    break;

UO.AddType(name, type) — UO.AddType(Any,Any)

Parametri: name (Any), type (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "addtype":

                    AddType(arguments);

                    break;

UO.ClickOnObject

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

Firme C#

void UO.ClickOnObject(object? objID);

Invia un singolo clic su un oggetto tramite GameActions.SingleClick.

Parametri

  • objID — Numero seriale dell'oggetto o nome supportato di self/backpack/lasttarget/oggetto salvato; le stringhe numeriche e le stringhe 0x vengono risolte dal runtime.

Valore restituito

void: nessun valore restituito.

Comportamento

  • Click risolve il collegamento tramite ObjectChecked. ClickOnObject usa prima Arg per serial e chiama Click(int). Questa è una richiesta per la firma/informazione dell'oggetto, non DoubleClick o l'utilizzo dell'oggetto. La risposta del server arriva in modo asincrono.

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

1. Fare clic su carattere - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Un singolo clic viene inviato a self.
UO.ClickOnObject("self");

2. Fare clic sull'ultimo target: funzione script

Parametri e flusso di esecuzione:

  • Prima dell'invio viene verificata l'esistenza locale della destinazione.
return  RunScenario();
 object? RunScenario()
{
    var target = UO.LastTarget();
    if (Truth(UO.Exists(target)))
    {
        UO.ClickOnObject(target);
    }

    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. Faranno clic sullo zaino - lezione di script

Parametri e flusso di esecuzione:

  • Un singolo clic su uno zaino non lo apre come farebbe doppio clic su di esso.
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.Backpack();
        if (Truth(bag != 0))
        {
            UO.ClickOnObject(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.ClickOnObject(objID) — UO.ClickOnObject(Any)

Parametri: objID (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "clickonobject": Click(Arg(0)); return InjectionValue.Unit;

UO.DeleteObject

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

Firme C#

void UO.DeleteObject(object? name);

Rimuove il nome dell'oggetto memorizzato dalla tabella di runtime.

Parametri

  • Nome name - string nella tabella Oggetti; Viene eliminata solo questa voce.

Valore restituito

void: nessun valore restituito.

Comportamento

  • Quando viene trovato un nome, cancella la voce e stampa una conferma; Se non c'è nessun nome, stampa il messaggio non trovato. L'oggetto server e il relativo contenuto non vengono eliminati.

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

1. Elimina il nome creato - script diretto

Parametri e flusso di esecuzione:

  • Viene rimossa solo la connessione temporanea con serial del personaggio.
UO.AddObject("temporary",UO.Self());
UO.DeleteObject("temporary");

2. Nome mancante: funzione dello script

Parametri e flusso di esecuzione:

  • Un nome mancante provoca un messaggio diagnostico.
return  RunScenario();
 object? RunScenario()
{
    UO.DeleteObject("missing-example-name");
    return null;
}

3. Memorizza il nome nella variabile - classe di script

Parametri e flusso di esecuzione:

  • La variabile string specifica la voce esatta da eliminare.
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 name = "temporary";
        UO.AddObject(name, UO.Self());
        UO.DeleteObject(name);
        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.DeleteObject(name) — UO.DeleteObject(String)

Parametri: name (String)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public void DeleteObject(string name)

        {

            if (objects.TryGet(name, out int value))

            {

                objects.Remove(name);

                SystemMessage($"Object {name} has been deleted");

            }

            else

                SystemMessage($"Object {name} not found");

        }

UO.Drag

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

Firme C#

int UO.Drag(object? id);
int UO.Drag(object? id, object? amount);
int UO.Drag(object? id, object? amount, object? timeout);
void UO.Drag(object? fromX, object? fromY, object? toX, object? toY);

Solleva un elemento specifico sul cursore; un modulo separato a quattro argomenti trascina il mouse in una finestra di Windows.

Parametri

  • id — Numero di serie di un oggetto/carattere specifico: numero, stringa esadecimale/decimale, self/backpack/lasttarget/lastobject/lastcontainer/lastcorpse/finditem/laststatus o nome salvato AddObject. Questo non è type. L'oggetto deve essere caricato; controllare Exists prima dell'azione.
  • amount — Numero di unità all'interno di uno stack. 0 o un valore negativo indica l'intero stack; il positivo è limitato dalla quantità disponibile. NON è il numero di stack che limita MassMove. Se assente, equivale a 0.
  • timeout - Terzo argomento opzionale: attende il Picking osservato fino al numero specificato di millisecondi; l'impostazione predefinita è 0. Un valore negativo è equivalente a 0.
  • fromX — Solo formato quattro int: la X iniziale del mouse nei pixel della finestra del client.
  • fromY - Mouse iniziale Y nei pixel della finestra del client.
  • toX — La X finale del mouse in pixel.
  • toY — La Y finale del mouse in pixel.

Valore restituito

Con argomenti 1..3 int: 1 — la richiesta di sollevamento è stata accettata dal cliente (con timeout>0 è stato osservato anche un cursore occupato); 0 — sollevamento rifiutato o timeout scaduto. Con quattro argomenti null: nessun valore restituito. Questo non è un elemento ID.

Comportamento

  • Per il trasferimento del gioco, la forma preferita è id[,importo[,timeout]] seguito da DropItem o un singolo MoveItem.
  • Il modulo fromX/fromY/toX/toY utilizza gli eventi del mouse di Windows: sposta, premi, sposta, rilascia. Non ha alcuna conferma da parte del server e dipende dal contenuto/focus effettivo della finestra.
  • Un cursore occupato non equivale a un trasferimento riuscito alla destinazione. La cattura e il rilascio sono azioni separate.

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

1. Raccogli l'intera pila e mettila nello zaino - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • bottino: da serial a AddObject. importo=0 indica l'intero stack; -1/-1 imposta la posizione automatica nel gump.
  • DropItem termina di acquisire lo stesso runtime. Uno significa che è stata inviata la richiesta, non la conferma del server.
if (Truth(UO.Drag("loot", 0)))
{
    var dropped = UO.DropItem("backpack", -1, -1, 0);
    UO.Print("Drop request: " + Convert.ToString(dropped));
}

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

2. Prendi parte allo stack con funzione script di attesa limitata

Parametri e flusso di esecuzione:

  • quantità=10 — fino a dieci unità di una pila; timeout=500ms.
  • 44/55 - coordinate all'interno dello zaino, non sulla mappa. Se l'oggetto non può essere preso, DropItem non viene chiamato.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Drag("loot", 10, 500)))
    {
        var dropped = UO.DropItem("backpack", 44, 55, 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;

3. Controlla le mani occupate prima della lezione di presa - script

Parametri e flusso di esecuzione:

  • Un argomento Drag indica l'intero stack e timeout=0.
  • Picking controlla il cursore condiviso del client. Non eseguire due migrazioni indipendenti contemporaneamente.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        if (Truth(UO.Picking() == 0))
        {
            if (Truth(UO.Drag("loot")))
            {
                var dropped = UO.DropItem("backpack", -1, -1, 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;
}

4. Quattro coordinate del mouse: script diretto

Parametri e flusso di esecuzione:

  • Questi sono i pixel della finestra: inizio (100,120), fine (260,180). Non c'è serial, importo o timeout.
  • Utilizzare solo quando gli elementi richiesti si trovano in questi luoghi; Per gli oggetti, l'indirizzamento tramite serial è più affidabile.
UO.Drag(100, 120, 260, 180);

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

Parametri: id (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int Drag(InjectionValue id) => Drag(id, InjectionValue.Zero, InjectionValue.Zero);

UO.Drag(id, amount) — UO.Drag(Any,Any)

Parametri: id (Any), amount (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int Drag(InjectionValue id, InjectionValue amount) => Drag(id, amount, InjectionValue.Zero);

UO.Drag(id, amount, timeout) — UO.Drag(Any,Any,Any)

Parametri: id (Any), amount (Any), timeout (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int Drag(InjectionValue id, InjectionValue amount, InjectionValue timeout)

        {

            int serial = GetObject(id);

            if (serial == 0)

                return 0;

            int requestedAmount = NumberConversions.ToInt(amount);

            int timeoutMs = Math.Max(0, NumberConversions.ToInt(timeout));

            int result = bridge.DragItem(serial, requestedAmount);

            if (result == 0 || timeoutMs <= 0)

                return result;



            DateTime deadline = DateTime.UtcNow.AddMilliseconds(timeoutMs);

            do

            {

                if (bridge.Picking() != 0)

                    return 1;

                if (DateTime.UtcNow >= deadline)

                    break;

                bridge.Wait(10);

            }

            while (true);



            SystemMessage($"UO.Drag: item pickup was not observable within {timeoutMs} ms.");

            return 0;

        }

UO.Drag(fromX, fromY, toX, toY) — UO.Drag(Integer,Integer,Integer,Integer)

Parametri: fromX (Integer), fromY (Integer), toX (Integer), toY (Integer)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public void Drag(int fromX, int fromY, int toX, int toY) => bridge.Drag(fromX, fromY, toX, toY);

UO.DragItem

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

Firme C#

dynamic UO.DragItem(object? objID, object? count);

Raccoglie un oggetto specifico e lo ricorda per DropItem questo runtime.

Parametri

  • objID — Numero di serie di un oggetto/carattere specifico: numero, stringa esadecimale/decimale, self/backpack/lasttarget/lastobject/lastcontainer/lastcorpse/finditem/laststatus o nome salvato AddObject. Questo non è type. L'oggetto deve essere caricato; controllare Exists prima dell'azione.
  • count — Numero di unità all'interno di uno stack. 0 o un valore negativo indica l'intero stack; il positivo è limitato dalla quantità disponibile. NON è il numero di stack che limita MassMove.

Valore restituito

int 1 — il cliente ha accettato l'aumento; 0 - articolo non trovato o PickUp rifiutato. Metadati di compatibilità object? non significa un tipo di risultato arbitrario. Questo non è serial.

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

  • Entrambi gli argomenti sono obbligatori. Non è prevista l'attesa di conferma; il formato Drag(id,amount,timeout) aggiunge un'attesa per il Picking locale.
  • Dopo una cattura riuscita, completa l'azione DropItem. Un elemento selezionato manualmente con il mouse non imposta la memoria DragItem di questo runtime.

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

1. Alza l'intero stack: script diretto

Parametri e flusso di esecuzione:

  • ObjID=bottino tramite AddObject, Count=0 è l'intero stack.
  • La seconda squadra lascia cadere lo stesso oggetto raccolto.
if (Truth(UO.DragItem("loot", 0)))
{
    var ok = UO.DropItem("backpack", -1, -1, 0);
}

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

2. Aumenta cinque unità - funzione script

Parametri e flusso di esecuzione:

  • Sostituisci ObjID con il tuo serial. Count=5 si riferisce alle unità dello stesso stack.
  • La posizione 44/55 è all'interno dello zaino.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.DragItem(0x40001234, 5)))
    {
        var ok = UO.DropItem("backpack", 44, 55, 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;

3. Mostra acquisizione non riuscita - Classe script

Parametri e flusso di esecuzione:

  • picked — int 1/0.
  • Non chiamare DropItem dopo una cattura fallita: il cursore potrebbe appartenere ad un'altra attività.
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 picked = UO.DragItem("loot", 0);
        if (Truth(picked == 0))
        {
            UO.Print("Item was not picked up");
        }
        else
        {
            var ok = UO.DropItem("backpack", -1, -1, 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;
}

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.DragItem(objID, count) — UO.DragItem(Any,Any)

Parametri: objID (Any), count (Any)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "dragitem": return new InjectionValue(bridge.DragItem(Arg(0), Arg(1)));

UO.Drop

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

Firme C#

int UO.Drop(object? @object);
int UO.Drop(object? @object, object? count);
int UO.Drop(object? @object, object? count, object? destination);
dynamic UO.Drop(object? objID, object? count, object? x, object? y, object? z);

Esegue un trasferimento completo dell'oggetto specificato, per impostazione predefinita al suolo sotto il personaggio.

Parametri

  • object — Numero di serie di un oggetto/carattere specifico: numero, stringa esadecimale/decimale, self/backpack/lasttarget/lastobject/lastcontainer/lastcorpse/finditem/laststatus o nome salvato AddObject. Questo non è type. L'oggetto deve essere caricato; controllare Exists prima dell'azione.
  • objID — Numero di serie di un oggetto/carattere specifico: numero, stringa esadecimale/decimale, self/backpack/lasttarget/lastobject/lastcontainer/lastcorpse/finditem/laststatus o nome salvato AddObject. Questo non è type. L'oggetto deve essere caricato; controllare Exists prima dell'azione.
  • count — Numero di unità all'interno di uno stack. 0 o un valore negativo indica l'intero stack; il positivo è limitato dalla quantità disponibile. NON è il numero di stack che limita MassMove. In forma abbreviata senza conteggio è 0.
  • destination - Solo nella forma con tre argomenti: Seriale del contenitore o nome del set AddObject; backpack/self/my scegli uno zaino, receiving/catchbag - SetCatchBag, e senza di esso uno zaino. lastcontainer/lastobject/lasttarget/lastcorpse/finditem/laststatus sono validi se risolti nel contenitore corretto. ground or 0 explicitly selects land; -1—the same backpack selector. Un nome sconosciuto o non specificato provoca un errore prima che l'elemento venga acquisito. Senza un argomento relativo alla destinazione, viene utilizzato lo zaino.
  • x - Solo nella forma a cinque argomenti: destinazione del mondo X sulla terra.
  • y - Mondo Y per la forma a cinque argomenti.
  • z - Altezza mondiale per la forma a cinque argomenti.

Valore restituito

int 1—richiesta di trasferimento completo accettata dal cliente; 0 - fallito. La forma compatibile con cinque argomenti ha metadati object?, ma in realtà restituisce anche int 1/0. Questo non è un reset del DragItem precedentemente preso: usa DropItem per questo.

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

  • Vengono registrati i moduli con argomenti 1, 2, 3 e 5. Non esiste un modulo con quattro argomenti.
  • Drop(oggetto) sposta l'intera pila sul terreno sottostante; Drop(item,count) specifica le unità; Drop(elemento,conteggio,destinazione) consente il contenitore.
  • Drop(oggetto,conteggio,X,Y,Z) significa sempre terra. Per un contenitore con coordinate gump, utilizzare MoveItem.
  • Si applicano restrizioni su sollevamento, DropCheckCoord e controllo del server. Il team non attende la conferma separata della consegna.

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

1. L'intero stack è sotto i tuoi piedi: una sceneggiatura diretta

Parametri e flusso di esecuzione:

  • object=bottino tramite AddObject, conteggio=0 per impostazione predefinita.
  • Destinazione: il punto attuale del personaggio sul terreno.
var ok = UO.Drop("loot");

2. Cinque unità in uno zaino - funzione script

Parametri e flusso di esecuzione:

  • count=5 unità di uno stack; destinazione=backpack.
  • Il terzo argomento qui è un contenitore, non X.
return  RunScenario();
 object? RunScenario()
{
    var ok = UO.Drop("loot", 5, "backpack");
    return null;
}

3. Punto esplicito sul terreno - classe scenario

Parametri e flusso di esecuzione:

  • Sostituisci ObjID con il tuo serial; Count=0 intero stack; X/Y/Z=1445/1690/0.
  • Per questo modulo, il terzo valore è X. Il Drag preliminare non è necessario.
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 ok = UO.Drop(0x40001234, 0, 1445, 1690, 0);
        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.Drop(object) — UO.Drop(Any)

Parametri: object (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "drop":

                    if (arguments.Length > 0)

                        return new InjectionValue(MoveItem(arguments[0], arguments.Length > 1 ? arguments[1] : InjectionValue.Zero, arguments.Length > 2 ? arguments[2] : new InjectionValue("ground")));

                    return InjectionValue.False;

UO.Drop(object, count) — UO.Drop(Any,Any)

Parametri: object (Any), count (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "drop":

                    if (arguments.Length > 0)

                        return new InjectionValue(MoveItem(arguments[0], arguments.Length > 1 ? arguments[1] : InjectionValue.Zero, arguments.Length > 2 ? arguments[2] : new InjectionValue("ground")));

                    return InjectionValue.False;

UO.Drop(object, count, destination) — UO.Drop(Any,Any,Any)

Parametri: object (Any), count (Any), destination (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "drop":

                    if (arguments.Length > 0)

                        return new InjectionValue(MoveItem(arguments[0], arguments.Length > 1 ? arguments[1] : InjectionValue.Zero, arguments.Length > 2 ? arguments[2] : new InjectionValue("ground")));

                    return InjectionValue.False;

UO.Drop(objID, count, x, y, z) — UO.Drop(Any,Any,Any,Any,Any)

Parametri: objID (Any), count (Any), x (Any), y (Any), z (Any)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "drop": return new InjectionValue(MoveItemChecked(Arg(0), Arg(1), 0, Arg(2), Arg(3), Arg(4)) ? 1 : 0);

UO.DropCheckCoord

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

Firme C#

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

Legge o modifica il controllo della portata delle coordinate quando si lasciano cadere oggetti a terra.

Parametri

  • value — Valore opzionale: 0 disabilita, int diverso da zero abilita. Senza argomento, lo stato viene solo letto.

Valore restituito

int 0/1 — stato attuale dopo l'eventuale registrazione; entrambe le forme restituiscono un numero.

Comportamento

  • MoveItemChecked quando assegnato a un terreno e la bandiera è accesa, rifiuta la distanza X/Y di Chebyshev maggiore di 2 celle dal personaggio. Il controllo non modifica le coordinate e non verifica l'autorizzazione del server al trasferimento. Le assegnazioni dei contenitori non sono limitate a questo flag.

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

1. Leggi flag - script diretto

Parametri e flusso di esecuzione:

  • Leggi restituisce l'impostazione normalizzata corrente.
var enabled = UO.DropCheckCoord();
UO.Print(Convert.ToString(enabled));

2. Abilita protezione intervallo - funzione script

Parametri e flusso di esecuzione:

  • I trasferimenti via terra attraverso MoveItemChecked sono ora limitati a due quadrati.
return  RunScenario();
 object? RunScenario()
{
    var enabled = UO.DropCheckCoord(1);
    UO.Print(Convert.ToString(enabled));
    return null;
}

3. Ripristina impostazione - Classe script

Parametri e flusso di esecuzione:

  • Il valore originale viene salvato e ripristinato in modo esplicito.
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 old = UO.DropCheckCoord();
        var temporary = UO.DropCheckCoord(0);
        var restored = UO.DropCheckCoord(old);
        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.DropCheckCoord() — UO.DropCheckCoord()

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "dropcheckcoord":

                    if (arguments.Length > 0) state.DropCheckCoord = Arg(0) != 0 ? 1 : 0;

                    return new InjectionValue(state.DropCheckCoord);

UO.DropCheckCoord(value) — UO.DropCheckCoord(Any)

Parametri: value (Any)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "dropcheckcoord":

                    if (arguments.Length > 0) state.DropCheckCoord = Arg(0) != 0 ? 1 : 0;

                    return new InjectionValue(state.DropCheckCoord);

UO.DropDelay

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

Firme C#

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

Legge o modifica il ritardo di runtime GrabDelay utilizzato dai trasferimenti di articoli.

Parametri

  • value - Ritardo opzionale in millisecondi; limiti del ponte a 50..10000.

Valore restituito

Senza argomento int con l'attuale GrabDelay. Il modulo di immissione restituisce null anche se i metadati di entrambi i moduli contengono object?.

Comportamento

  • SetDropDelay e GetDropDelay usano lo Stato. GrabDelay. L'impostazione specifica il ritardo dei trasferimenti da parte del client, anziché la conferma del loro completamento da parte del server.

Script C# autonomi

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

Esempio semplice

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

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

1. Ritardo di lettura: script diretto

Parametri e flusso di esecuzione:

  • La lettura restituisce millisecondi.
var ms = UO.DropDelay();
UO.Print(Convert.ToString(ms));

2. Imposta ritardo - Funzione script

Parametri e flusso di esecuzione:

  • La voce imposta 250 ms.
return  RunScenario();
 object? RunScenario()
{
    UO.DropDelay(250);
    return null;
}

3. Bordo inferiore: classe di script

Parametri e flusso di esecuzione:

  • Lo zero è limitato a 50 ms, dopodiché viene ripristinato al valore precedente.
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 previous = UO.DropDelay();
        UO.DropDelay(0);
        UO.Print(Convert.ToString(UO.DropDelay()));
        UO.DropDelay(previous);
        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.DropDelay() — UO.DropDelay()

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "dropdelay":

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

                    return new InjectionValue(bridge.GetDropDelay());

UO.DropDelay(value) — UO.DropDelay(Any)

Parametri: value (Any)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "dropdelay":

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

                    return new InjectionValue(bridge.GetDropDelay());

UO.DropHere

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

Firme C#

int UO.DropHere(object? @object);

Trasferisce l'intero oggetto/pila specificato a terra nel punto attuale del personaggio.

Parametri

  • object — Numero di serie di un oggetto/carattere specifico: numero, stringa esadecimale/decimale, self/backpack/lasttarget/lastobject/lastcontainer/lastcorpse/finditem/laststatus o nome salvato AddObject. Questo non è type. L'oggetto deve essere caricato; controllare Exists prima dell'azione.

Valore restituito

int 1 — la richiesta di trasferimento è stata accettata dal cliente; 0 - non completato. Questa non è serial o la conferma del server.

Il risultato del comando è un flag numerico: 1 significa una condizione soddisfatta, 0 significa una condizione non soddisfatta. Dopo var risultato = comando(...) controlla se (risultato != 0) o se (risultato == 0). Salva il risultato di una chiamata: una chiamata ripetuta può eseguire nuovamente l'azione o leggere lo stato che è già cambiato.

Comportamento

  • Un modulo è stato registrato esattamente con un argomento. Per parte dello stack, usa Drop(item,count) o MoveItem.
  • X/Y/Z vengono presi dal personaggio durante la chiamata. Non è richiesto alcun DragItem precedente.

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

1. Lancia un oggetto noto: sceneggiatura diretta

Parametri e flusso di esecuzione:

  • object - serial, sostituisci con reale.
  • L'intero stack viene trasferito al personaggio.
var ok = UO.DropHere(0x40001234);

2. Utilizza nome salvato - Funzione script

Parametri e flusso di esecuzione:

  • il bottino è specificato tramite AddObject.
  • Exists controlla la disponibilità anziché l'autorizzazione del server per la migrazione.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Exists("loot")))
    {
        var ok = UO.DropHere("loot");
    }

    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. Gestire gli errori del client: classe di script

Parametri e flusso di esecuzione:

  • ok — int 1/0.
  • Per confermare il risultato del server, controlla separatamente la posizione e il contenitore dell'articolo.
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 ok = UO.DropHere("loot");
        if (Truth(ok == 0))
        {
            UO.Print("Drop request was not accepted");
        }

        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.DropHere(object) — UO.DropHere(Any)

Parametri: object (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "drophere":

                    if (arguments.Length > 0)

                        return new InjectionValue(MoveItem(arguments[0], arguments.Length > 1 ? arguments[1] : InjectionValue.Zero, new InjectionValue("ground"), new InjectionValue(GetX()), new InjectionValue(GetY()), new InjectionValue(GetZ())));

                    return InjectionValue.False;

UO.DropItem

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

Firme C#

dynamic UO.DropItem(object? moveIntoID, object? x, object? y, object? z);

Reimposta un elemento precedentemente raccolto con successo tramite Drag/DragItem nello stesso runtime.

Parametri

  • moveIntoID — Destinazione seriale, backpack o imposta il nome AddObject. Il numero 0 significa terra. Usa backpack anziché self: questo argomento di basso livello risolve self in serial di un personaggio.
  • x — Per un contenitore — posizionalo all'interno del gump (-1/65535 automaticamente); per la terra - mondo X.
  • y — Per un contenitore — posizionalo all'interno del gump (-1/65535 automaticamente); per la terra - mondo Y.
  • z — Ripristina altezza; nel contenitore solitamente 0, a terra il punto Z effettivo.

Valore restituito

int 1 - il reset è stato inviato e il cursore è contrassegnato Dropped; 0 - Non è andato a buon fine DragItem, il cursore è cambiato/non accessibile o l'assegnazione non è valida. Metadati object? la compatibilità non modifica questo risultato. Non è una quantità o serial.

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

  • Tutti e quattro gli argomenti sono obbligatori. Questa opzione non riprende l'oggetto; Drop e MoveItem eseguono un riporto completo serial.
  • Viene verificato che ad essere trattenuto sia l'elemento memorizzato da questo runtime. Un oggetto preso da qualcun altro o preso con le mani non deve cadere accidentalmente.
  • Dopo l'invio, la memoria di acquisizione viene cancellata. L'impostazione GrabDelay aggiunge una pausa al flusso dello script. Il guasto del server è possibile dopo la restituzione.

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

1. Spazio automatico nello zaino - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • MoveIntoID=backpack, X/Y=-1, Z=0.
  • L'acquisizione riuscita viene verificata prima del rilascio.
if (Truth(UO.DragItem("loot", 0)))
{
    var ok = UO.DropItem("backpack", -1, -1, 0);
}

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

2. Spazio all'interno del torace - funzione dello script

Parametri e flusso di esecuzione:

  • il petto è specificato tramite AddObject. X=60/Y=70 — coordinate nel suo gump.
  • importo=10 si riferisce a Drag, DropItem non ha una propria quantità.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Drag("loot", 10)))
    {
        var ok = UO.DropItem("chest", 60, 70, 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;

3. Posizionalo a terra sotto la classe personaggio - scenario

Parametri e flusso di esecuzione:

  • MoveIntoID=0 seleziona chiaramente il terreno.
  • X/Y/Z è il punto del mondo, non le coordinate del contenitore.
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 x = UO.GetX();
        var y = UO.GetY();
        var z = UO.GetZ();
        if (Truth(UO.DragItem("loot", 0)))
        {
            var ok = UO.DropItem(0, x, y, z);
        }

        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.DropItem(moveIntoID, x, y, z) — UO.DropItem(Any,Any,Any,Any)

Parametri: moveIntoID (Any), x (Any), y (Any), z (Any)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "dropitem": return new InjectionValue(bridge.DropDraggedItem(Arg(0), Arg(1), Arg(2), Arg(3)));

UO.Dye

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

Firme C#

void UO.Dye(object? dyeObject);
void UO.Dye(object? dyeObject, object? target);

Utilizza l'oggetto colorante trasferito; il secondo argomento preimposta l'oggetto UO.Wait-target.

Parametri

  • dyeObject — Numero seriale dell'oggetto o nome supportato di self/backpack/lasttarget/oggetto salvato; le stringhe numeriche e le stringhe 0x vengono risolte dal runtime.
  • target - Oggetto opzionale/serial target successivo. Senza il secondo argomento non viene fissato un nuovo obiettivo.

Valore restituito

void: nessun valore restituito.

Comportamento

  • La forma a due argomenti chiama prima WaitTargetObject(target), poi UseObject(dyeObject). La forma con un argomento utilizza solo l'oggetto. Questo sta inviando azioni; colore, colorazione giusta e totale sono determinati dal server.

Script C# autonomi

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

Esempio semplice

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

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

UO.Print("Calling UO.Dye");
UO.Dye(UO.LastObject());

1. Usa elemento colorante - Script diretto

Parametri e flusso di esecuzione:

  • Una chiamata con un argomento non specifica una destinazione.
var dye = UO.LastObject();
if (Truth(UO.Exists(dye)))
{
    UO.Dye(dye);
}

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

2. Colore target selezionato - funzione script

Parametri e flusso di esecuzione:

  • Target viene posizionato prima del doppio clic sul colorante.
return  RunScenario();
 object? RunScenario()
{
    var dye = UO.LastObject();
    var target = UO.LastTarget();
    if (Truth(UO.Exists(dye)) && Truth(UO.Exists(target)))
    {
        UO.Dye(dye, target);
    }

    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. Nomi salvati - Classe di script

Parametri e flusso di esecuzione:

  • Nell'esempio vengono utilizzati i nomi tintura e stoffa salvati in precedenza.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        if (Truth(UO.Exists("dye")) && Truth(UO.Exists("cloth")))
        {
            UO.Dye("dye", "cloth");
        }

        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.Dye(dyeObject) — UO.Dye(Any)

Parametri: dyeObject (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "dye":

                    if (arguments.Length > 1) bridge.WaitTargetObject(Arg(1));

                    bridge.UseObject(Arg(0, bridge.GetLastObject()));

                    break;

UO.Dye(dyeObject, target) — UO.Dye(Any,Any)

Parametri: dyeObject (Any), target (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "dye":

                    if (arguments.Length > 1) bridge.WaitTargetObject(Arg(1));

                    bridge.UseObject(Arg(0, bridge.GetLastObject()));

                    break;

UO.EasyObject

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

Firme C#

void UO.EasyObject(object? name);
void UO.EasyObject(object? name, object? @object);

Memorizza il nome dell'oggetto senza una query di destinazione interattiva.

Parametri

  • name — Il nome della voce Oggetti runtime, che si risolve in string.
  • object - Opzionale serial/link. Senza di esso, GetLastObject viene preservato.

Valore restituito

void: nessun valore restituito.

Comportamento

  • State.Objects.Set sostituisce la voce del nome. La forma con un argomento utilizza l'ultimo oggetto utilizzato anziché LastTarget. La presenza di un oggetto nel mondo non viene verificata separatamente da questo ramo.

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.EasyObject");
UO.EasyObject("last-used");

1. Salva l'ultimo oggetto - script diretto

Parametri e flusso di esecuzione:

  • Il nome è dato all'attuale LastObject.
UO.EasyObject("last-used");

2. Salva te stesso - funzione script

Parametri e flusso di esecuzione:

  • La forma a due argomenti preserva il serial passato.
return  RunScenario();
 object? RunScenario()
{
    UO.EasyObject("me", UO.Self());
    return null;
}

3. Elimina voce temporanea - Classe script

Parametri e flusso di esecuzione:

  • Forget cancella solo l'associazione del nome salvata.
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.EasyObject("temporary", UO.Self());
        UO.Forget("temporary");
        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.EasyObject(name) — UO.EasyObject(Any)

Parametri: name (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "easyobject":

                    if (arguments.Length > 1) state.Objects.Set(Text(0), Arg(1));

                    else if (arguments.Length > 0) state.Objects.Set(Text(0), bridge.GetLastObject());

                    break;

UO.EasyObject(name, object) — UO.EasyObject(Any,Any)

Parametri: name (Any), object (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "easyobject":

                    if (arguments.Length > 1) state.Objects.Set(Text(0), Arg(1));

                    else if (arguments.Length > 0) state.Objects.Set(Text(0), bridge.GetLastObject());

                    break;

UO.EmptyContainer

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

Firme C#

int UO.EmptyContainer(object? delay);
int UO.EmptyContainer(object? delay, object? source);
int UO.EmptyContainer(object? delay, object? source, object? destination);

Trasferisce tutto il contenuto diretto di una cassa, una borsa o un cadavere nel contenitore specificato. Il primo parametro è sempre il ritardo in millisecondi. Se non viene specificata alcuna origine, viene visualizzato un ambito locale: selezionare il contenitore di origine. La destinazione predefinita è lo zaino del personaggio attuale.

Parametri

  • delay — Primo parametro richiesto: ritardo tra i trasferimenti, in millisecondi. Ad esempio 350 - 0,35 secondi. Vengono utilizzati valori interi; quelli negativi si riducono a 0. GrabDelay non viene aggiunto separatamente a questo ritardo. L'ultima pausa viene salvata in modo che la riga successiva non superi l'ultima richiesta.
  • source — Secondo parametro opzionale: serial del contenitore di origine, una stringa numerica/esadecimale o il nome dell'oggetto salvato. Sono supportati lastobject, lastcontainer, lasttarget, lastcorpse, backpack/my. Se il parametro manca o è uguale a 0, appare un mirino. Seleziona un oggetto contenitore o un cadavere; Esc annulla l'azione.
  • destination - Il terzo parametro opzionale è serial o il nome salvato del contenitore di destinazione. backpack/self/my seleziona lo zaino del personaggio. receiving/catchbag seleziona il contenitore SetCatchBag installato (o lo zaino se non installato). lastcontainer/lastobject/lasttarget/lastcorpse/finditem/laststatus sono validi se si risolvono in un contenitore accessibile. Un alias sconosciuto o non impostato genera un errore. Se il parametro non è specificato viene utilizzato lo zaino; l'impostazione del contenitore receiving non modifica questa scelta. La destinazione deve esistere ed essere diversa dall'origine. Ground/0 non è un contenitore di destinazione valido qui.

Valore restituito

int: 1 se la sorgente non fosse vuota e si potesse inviare una richiesta di trasferimento per ciascuna voce diretta selezionata; 0 quando la sorgente è vuota, l'ambito è annullato, la destinazione non è corretta, timeout del download o errore di invio parziale/completo. Questo è il risultato delle richieste del client, non una garanzia di svuotamento confermato dal server.

Comportamento

  • Forme esatte: EmptyContainer(ritardo), EmptyContainer(ritardo, sorgente), EmptyContainer(ritardo, sorgente, destinazione). Nella chat di gioco con il prefisso standard: ,emptycontainer 350; dalla sceneggiatura: UO.EmptyContainer(350).
  • Durante la mira, il comando attende la selezione, l'annullamento o l'arresto di emergenza. Il client continua ad aggiornare l'immagine e la rete. Esc non invia alcun riporto, non utilizza il vecchio oggetto e restituisce 0. Se un'altra vista sostituisce questa selezione, anche l'azione viene annullata.
  • Se il contenuto non è stato ancora scaricato, il client apre il sorgente e attende fino a 3000 ms affinché il server risponda. Il contenuto nascosto al client non può essere trasferito senza ottenere i dati del server. Un forziere inaccessibile/troppo lontano o un ban da parte del server comporteranno un fallimento invece della selezione di un altro contenitore.
  • Dopo aver ricevuto i dati, viene creato un elenco di elementi diretti. Ogni stack viene migrato nella sua interezza, con una richiesta di acquisizione e reimpostazione alla volta. La borsa allegata viene trasportata interamente; i suoi contenuti non vengono cercati separatamente. I nuovi elementi aggiunti in seguito non sono inclusi nell'elenco corrente.
  • Prima di ogni richiesta viene ricontrollato che l'articolo sia ancora nel contenitore originale. Non è possibile nidificare un contenitore all'interno di se stesso o del proprio figlio. Se il cursore è occupato da un altro elemento, il comando non lo ripristina per tuo conto.
  • Un contenitore di destinazione mancante non viene sostituito da uno zaino. Un risultato 1 non significa che il server ha accettato tutte le azioni: se necessario, controlla il contenuto dopo aver aggiornato il server. Un arresto di emergenza interrompe l'attesa; Le azioni già inviate non vengono annullate.
  • Un nome memorizzato sconosciuto o un formato di argomento non valido provoca un errore API anziché un ritorno 0. Distinguerlo da un oggetto mancante serial valido: per questo l'operazione restituisce 0.

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

1. Seleziona una cassa o un cadavere con una vista e trasferiscilo nello zaino - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • L'unico parametro delay=350 specifica l'intervallo 350 ms. manca la fonte, quindi appare il mirino.
  • manca anche la destinazione: il contenuto va nello zaino del personaggio. Scegli il contenitore/cadavere stesso, non solo un oggetto al suo interno.
  • inviato riceve 1 o 0. Il significato di 0 unisce cancellazione, vuoto e fallimento; Vedi anche la rivista per i dettagli.
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;

2. Da un famoso baule a uno zaino senza scopo - funzione di script

Parametri e flusso di esecuzione:

  • ritardo=350; la fonte è la serial reale del torace, sostituisci la ID approssimativa con la tua. La vista non appare.
  • Il terzo parametro non è specificato, quindi destinazione=backpack. Tutti i tipi di articoli diretti e pile complete sono inclusi nel riporto.
  • Print visualizza il risultato dell'invio da parte del client, non il numero di elementi o la conferma del server.
return  RunScenario();
 object? RunScenario()
{
    var source = "0x40001234";
    var sent = UO.EmptyContainer(350, source);
    UO.Print("Client request result: " + Convert.ToString(sent));
    return null;
}

3. Tra due contenitori selezionati: classe di script

Parametri e flusso di esecuzione:

  • AddObject con un parametro richiede di selezionare un oggetto e ne salva il nome. Le due selezioni vengono effettuate in sequenza.
  • U EmptyContainer delay=350; fonte=borsa_fonte; destinazione=bagagli_destinazione. Il terzo parametro specifica una borsa specifica anziché uno zaino.
  • I nomi devono riferirsi a contenitori diversi. La AddObject cancellata rimuove il significato precedente del suo nome, quindi la vecchia borsa non viene utilizzata accidentalmente.
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.Print("Select source");
        UO.AddObject("source_bag");
        UO.Print("Select destination");
        UO.AddObject("destination_bag");
        var sent = UO.EmptyContainer(350, "source_bag", "destination_bag");
        UO.Print("Client request result: " + Convert.ToString(sent));
        return null;
    }
}

4. Dall'ultimo contenitore aperto a un determinato baule: sceneggiatura diretta

Parametri e flusso di esecuzione:

  • ritardo=500 — intervallo di mezzo secondo. source=lastcontainer - l'ultimo contenitore aperto dal server in questo client.
  • destinazione - esplicito ID del tuo petto; sostituire esempio. lastcontainer e lastobject hanno significati diversi: l'ultimo contenitore aperto e l'ultimo oggetto utilizzato.
  • Prima di iniziare, assicurati che l'ultima fonte che hai aperto fosse quella che ti serve. Il carry non apre ricorsivamente i suoi bag annidati.
var destination = "0x40005678";
UO.EmptyContainer(500, "lastcontainer", destination);

5. Seleziona una fonte a vista, specifica la destinazione in anticipo - funzione script

Parametri e flusso di esecuzione:

  • ritardo=350; source=0 chiama specificamente l'ambito, pur mantenendo la possibilità di passare un terzo parametro.
  • destinazione=la memoria punta a un forziere salvato in precedenza. Una volta selezionata una fonte, il contenuto viene trasferito lì.
  • Esc restituisce sent=0 senza andare a capo. Se l'archivio è sconosciuto o non esiste, un altro contenitore non viene selezionato automaticamente.
return  RunScenario();
 object? RunScenario()
{
    UO.AddObject("storage", "0x40005678");
    var sent = UO.EmptyContainer(350, 0, "storage");
    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.EmptyContainer(delay) — UO.EmptyContainer(Any)

Parametri: delay (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "emptycontainer": return ExecuteEmptyContainer(arguments);

UO.EmptyContainer(delay, source) — UO.EmptyContainer(Any,Any)

Parametri: delay (Any), source (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "emptycontainer": return ExecuteEmptyContainer(arguments);

UO.EmptyContainer(delay, source, destination) — UO.EmptyContainer(Any,Any,Any)

Parametri: delay (Any), source (Any), destination (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "emptycontainer": return ExecuteEmptyContainer(arguments);

UO.Exists

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

Firme C#

int UO.Exists(object? id);

Verifica la presenza di un oggetto non eliminato nel mondo locale del client.

Parametri

  • id — 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 - serial ora si risolve nell'oggetto caricato o mobile. int 0 - l'oggetto è sconosciuto al client, cancellato o l'alias non è impostato. Questa non è una risposta del server sull'esistenza di un oggetto: un elemento al di fuori dell'area visibile può esistere sul server e fornire qui 0.

Il risultato del comando è un flag numerico: 1 significa una condizione soddisfatta, 0 significa una condizione non soddisfatta. Dopo var risultato = comando(...) controlla se (risultato != 0) o se (risultato == 0). Salva il risultato di una chiamata: una chiamata ripetuta può eseguire nuovamente l'azione o leggere lo stato che è già cambiato.

Comportamento

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

1. Controlla se lo zaino è disponibile - script diretto

Parametri e flusso di esecuzione:

  • L'argomento backpack è un alias serial dello zaino del tuo personaggio.
  • 1 non significa che il contenuto dello zaino sia già stato completamente ricevuto o che sia stato aperto.
var present = UO.Exists("backpack");
if (Truth(present))
{
    UO.Print("Backpack is loaded");
}
else
{
    UO.Print("Backpack is unavailable");
}

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

2. Ricontrolla la funzione salvata serial - script

Parametri e flusso di esecuzione:

  • target memorizza lo specifico serial. Il nuovo valore lasttarget non lo sostituirà.
  • Dopo la pausa 500 ms, l'oggetto potrebbe non essere più visibile, quindi il controllo viene eseguito nuovamente.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var target = UO.GetSerial("lasttarget");
    await Delay(500);
    if (Truth(UO.Exists(target)))
    {
        UO.Print(UO.GetName(target));
    }
    else
    {
        UO.Print("Saved target is no longer loaded");
    }

    return null;
}

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

3. Distinguere la formattazione ID dalla presenza dell'oggetto - classe script

Parametri e flusso di esecuzione:

  • GetSerial formatta il numero 1073746484 come 0x40001234 anche se non è presente alcun oggetto.
  • Solo il controllo successivo riporta la presenza di questo serial nell'attuale mondo locale.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var serial = UO.GetSerial("1073746484");
        UO.Print("Serial: " + serial);
        var present = UO.Exists(serial);
        UO.Print("Present 1/0: " + Convert.ToString(present));
        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.Exists(id) — UO.Exists(Integer)

Parametri: id (Integer/String)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

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

UO.Exists(id) — UO.Exists(String)

Parametri: id (Integer/String)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

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

UO.Forget

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

Firme C#

void UO.Forget(object? name);

Senza messaggio, rimuove il nome memorizzato dagli oggetti runtime.

Parametri

  • name — Il nome della voce che viene convertito in string.

Valore restituito

void: nessun valore restituito.

Comportamento

  • Il ramo chiama state.Objects.Remove. A differenza di DeleteObject, questo modulo non stampa una conferma né segnala un nome mancante. L'oggetto del mondo di gioco non viene eliminato.

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

1. Elimina nome temporaneo - script diretto

Parametri e flusso di esecuzione:

  • Viene rimossa solo l'associazione del nome con serial.
UO.EasyObject("temporary",UO.Self());
UO.Forget("temporary");

2. Nome mancante: funzione dello script

Parametri e flusso di esecuzione:

  • È consentito un nome mancante senza messaggio.
return  RunScenario();
 object? RunScenario()
{
    UO.Forget("missing-example-name");
    return null;
}

3. Nome dalla variabile - classe di script

Parametri e flusso di esecuzione:

  • La cancellazione si riferisce alla stringa esatta del nome.
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 name = "temporary";
        UO.EasyObject(name, UO.Self());
        UO.Forget(name);
        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.Forget(name) — UO.Forget(Any)

Parametri: name (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "forget": if (arguments.Length > 0) state.Objects.Remove(Text(0)); break;

UO.GetAltName

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

Firme C#

dynamic UO.GetAltName(object? objID);

Legge il titolo del personaggio noto al cliente: ad esempio professione o firma dopo il nome.

Parametri

  • objID — Richiesto l'oggetto serial/ID, non type e non cliloc. Accetta int, stringa decimale/esadecimale, self, backpack, lasttarget, trovaelemento o nome AddObject. 0 significa nessun oggetto.

Valore restituito

string — testo del campo Titolo per dispositivi mobili. Stringa vuota se il titolo è sconosciuto, l'oggetto non è un carattere o manca ID. Non è serial, un nome completo o un array di proprietà. GetAltName utilizza lo stesso campo di GetTitle.

Comportamento

  • La chiamata stessa legge i dati locali, non attende il server e non invia un solo clic. Per richiedere un nome/titolo utilizzare da solo ClickOnObject; la risposta arriva in modo asincrono.
  • Per un carattere esistente è accettabile anche una stringa vuota. Il controllo Exists risponde ad un'altra domanda: se l'oggetto è caricato.
  • In questa implementazione, il nome alternativo viene mappato nel campo Titolo del personaggio.

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

1. Titolo del tuo personaggio: sceneggiatura diretta

Parametri e flusso di esecuzione:

  • ObjID=self — carattere del client corrente.
  • titolo contiene solo il titolo; un campo vuoto non significa un errore di script.
var title = UO.GetAltName("self");
UO.Print(title);

2. Controlla il carattere selezionato - funzione script

Parametri e flusso di esecuzione:

  • ObjID=id — serial dell'ultimo target. GetName e il titolo vengono letti separatamente.
  • La destinazione dell'elemento non ha un campo Titolo e fornirà una stringa vuota.
return  RunScenario();
 object? RunScenario()
{
    var id = UO.GetSerial("lasttarget");
    if (Truth(UO.Exists(id)))
    {
        var title = UO.GetAltName(id);
        if (Truth(title != ""))
        {
            UO.Print(UO.GetName(id) + " " + title);
        }
    }

    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. Richiedi il nome prima della lettura: classe di script

Parametri e flusso di esecuzione:

  • 350 — esempio di pausa in millisecondi dopo un singolo clic; questo non è un parametro getter.
  • Il server potrebbe rispondere più tardi o non trasferire il titolo. Conserva la gestione della stringa vuota.
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.ClickOnObject(id);
            UO.Wait(350);
            UO.Print(UO.GetAltName(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.GetAltName(objID) — UO.GetAltName(Any)

Parametri: objID (Any)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "getaltname": return new InjectionValue(bridge.GetAltName(Arg(0)));

UO.GetColor

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

Firme C#

string UO.GetColor();
string UO.GetColor(object? id);

Legge l'oggetto hue e lo formatta come una stringa esadecimale.

Parametri

  • id è il Serial/ID dell'oggetto, non graphic/type. Numero, stringa esadecimale, nome standard self/backpack/lasttarget/lastobject/lastcontainer/laststatus/finditem/lastcorpse o nome AddObject. L'alias deve essere impostato; l'esistenza è controllata da Exists. La forma registrata senza argomenti utilizza self.

Valore restituito

string della forma "0x0481" - codice hue/colore, quattro cifre esadecimali dopo 0x. Per un oggetto mancante, viene restituito "0x0000"; lo stesso codice si verifica per un articolo non verniciato. Il colore non è graphic/type o unico serial.

Comportamento

  • Vengono letti gli ultimi dati già noti al client; la richiesta di aggiornamento non viene inviata al server.
  • Un oggetto sconosciuto e una proprietà non ancora recuperata possono avere un valore nullo/vuoto. Controlla Exists e le condizioni di una particolare azione.

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

1. Scopri il colore dell'ultimo oggetto: sceneggiatura diretta

Parametri e flusso di esecuzione:

  • id=lastobject - ultimo oggetto utilizzato.
  • Il risultato è già una stringa esadecimale e non richiede Int2Hex.
var hue = UO.GetColor("lastobject");
UO.Print(hue);

2. Cerca un oggetto dello stesso colore - funzione script

Parametri e flusso di esecuzione:

  • type e hue sono caratteristiche diverse del campione; FindType accetta entrambe le rappresentazioni esadecimali.
  • corrispondenza - trovato serial o una stringa vuota. Il colore non sostituisce type.
return  RunScenario();
 object? RunScenario()
{
    var sample = UO.GetSerial("lastobject");
    if (Truth(UO.Exists(sample)))
    {
        var type = UO.GetGraphic(sample);
        var hue = UO.GetColor(sample);
        var match = UO.FindType(type, hue, "backpack");
        UO.Print(match);
    }

    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. Converti hue in numero intero per il confronto - classe di script

Parametri e flusso di esecuzione:

  • GetColor legge self; Hex2Int converte il testo esadecimale in int.
  • Il null hue di per sé non dice se un personaggio è presente nel mondo.
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 hue = UO.Hex2Int(UO.GetColor("self"));
        if (Truth(hue == 0))
        {
            UO.Print("Hue is zero");
        }

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

Parametri: Nessun parametro.

Risultato: string / String.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public string GetColor() => GetColor(new InjectionValue(bridge.Self));

UO.GetColor(id) — UO.GetColor(Any)

Parametri: id (Any)

Risultato: string / String.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public string GetColor(InjectionValue id) => NumberConversions.ToHex((short)bridge.GetColor(GetObject(id)));

UO.GetFlags

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

Firme C#

int UO.GetFlags(object? id);

Legge la maschera di bit Entity.Flags da un oggetto noto locale.

Parametri

  • id — Numero seriale dell'oggetto o nome supportato di self/backpack/lasttarget/oggetto salvato; le stringhe numeriche e le stringhe 0x vengono risolte dal runtime.

Valore restituito

int - Entity.Flags originale. L'entità sconosciuta/mancante restituisce 0; è una maschera, non un risultato logico.

Comportamento

  • GetObject risolve il collegamento, quindi bridge.World.Get legge Entity.Flags nel flusso del gioco. Un valore nullo potrebbe significare un oggetto senza flag o senza modello; Exists separates these cases. The command does not request a status update.

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

1. Segnala te stesso: script diretto

Parametri e flusso di esecuzione:

  • Viene visualizzata la maschera del carattere corrente.
var flags = UO.GetFlags("self");
UO.Print(Convert.ToString(flags));

2. Flag di destinazione noti - Funzionalità script

Parametri e flusso di esecuzione:

  • Il test Exists distingue il modello mancante.
return  RunScenario();
 object? RunScenario()
{
    var id = UO.LastTarget();
    if (Truth(UO.Exists(id)))
    {
        var flags = UO.GetFlags(id);
        UO.Print(Convert.ToString(flags));
    }

    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. Manca serial - classe di script

Parametri e flusso di esecuzione:

  • Un serial nullo di solito non corrisponde a un'entità e restituisce 0.
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 flags = UO.GetFlags(0);
        UO.Print(Convert.ToString(flags));
        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.GetFlags(id) — UO.GetFlags(Any)

Parametri: id (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

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

UO.GetGraphic

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

Firme C#

string UO.GetGraphic();
string UO.GetGraphic(object? id);

Legge graphic di un elemento o body di un carattere e lo restituisce in testo esadecimale.

Parametri

  • id — Numero di serie di un oggetto specifico o un alias risolvibile, ad esempio "self", "backpack", "lasttarget" o il nome salvato da AddObject. Il grafico/type non viene trasferito qui. La forma senza argomenti utilizza self.

Valore restituito

string della forma "0x0EED" - oggetto grafico type/body. Questo non è un ID/serial unico. Per un oggetto sconosciuto, bridge restituisce graphic 0, che è formattato come "0x0000". Il comando non restituisce true/false.

Comportamento

  • Il comando legge i dati locali del client. Non invia target e non modifica l'oggetto sul server.
  • Il numero 0 può essere un valore di dati valido. Verifica l'assenza di un oggetto tramite Exists(serial) e non solo tramite il valore della sua proprietà.

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

1. Controlla type di un oggetto trovato - script diretto

Parametri e flusso di esecuzione:

  • FindType riceve type oro e restituisce serial.
  • GetGraphic(serial) restituisce il testo "0x0EED"; le variabili item e graphic hanno significati diversi.
var item = UO.FindType(0x0EED, -1, "backpack");
if (Truth(item != ""))
{
    var graphic = UO.GetGraphic(item);
    UO.Print("Graphic: " + graphic);
}

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

2. Leggi la funzione script body del tuo personaggio

Parametri e flusso di esecuzione:

  • La forma senza argomenti utilizza self.
  • body è il codice per l'aspetto del personaggio, non il suo serial.
return  RunScenario();
 object? RunScenario()
{
    var body = UO.GetGraphic();
    UO.Print("Body graphic: " + body);
    return null;
}

3. Passa read graphic alla nuova ricerca - classe script

Parametri e flusso di esecuzione:

  • lastobject—campione; graphic è una stringa esadecimale che FindType accetta come type.
  • -1 consente qualsiasi colore, backpack specifica l'area di ricerca. sameType è di nuovo serial.
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 graphic = UO.GetGraphic("lastobject");
        var sameType = UO.FindType(graphic, -1, "backpack");
        if (Truth(sameType != ""))
        {
            UO.Print("Matching serial: " + sameType);
        }

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

Parametri: Nessun parametro.

Risultato: string / String.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public string GetGraphics() => GetGraphics(bridge.Self);

UO.GetGraphic(id) — UO.GetGraphic(Integer)

Parametri: id (Integer/String)

Risultato: string / String.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public string GetGraphics(int id) => $"0x{bridge.GetGraphics(id):X4}";

UO.GetGraphic(id) — UO.GetGraphic(String)

Parametri: id (Integer/String)

Risultato: string / String.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public string GetGraphics(string id) => GetGraphics(GetObject(id));

UO.GetLayer

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

Firme C#

string UO.GetLayer();
string UO.GetLayer(object? id);

Parametri

  • id — Numero di serie di un oggetto specifico o un alias risolvibile, ad esempio "self", "backpack", "lasttarget" o il nome salvato da AddObject. Il grafico/type non viene trasferito qui. La forma senza argomenti utilizza self.

Valore restituito

string è il nome del livello, come "Rhand", "Lhand", "Hat", "Bpack" o "Mount". Viene restituito il primo nome canonico per il numero del livello, quindi Casco viene restituito come "Hat" e Backpack come "Bpack". Livello 0, oggetto sconosciuto o self danno "Non valido". Un numero sconosciuto diverso da zero viene formattato come "0xNN". Non è serial, non graphic e non è l'altezza Z.

Comportamento

  • Il comando legge i dati locali del client. Non invia target e non modifica l'oggetto sul server.
  • Il numero 0 può essere un valore di dati valido. Verifica l'assenza di un oggetto tramite Exists(serial) e non solo tramite il valore della sua proprietà.

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

1. Determina il livello di un oggetto nella mano destra: script diretto

Parametri e flusso di esecuzione:

  • ObjAtLayer("Rhand") seleziona un elemento sulla mano destra; 0 significa slot vuoto.
  • GetLayer riceve serial dell'oggetto trovato e restituisce la stringa "Rhand".
object? item = UO.ObjAtLayer("Rhand");
if (item is string serial)
{
    var layer = UO.GetLayer(serial);
    UO.Print(layer);
}

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

2. Controlla il nome del livello dello zaino - Funzione script

Parametri e flusso di esecuzione:

  • id="backpack" — serial dello zaino del personaggio attuale.
  • Viene selezionato il nome canonico Bpack, non l'alias Backpack.
return  RunScenario();
 object? RunScenario()
{
    var layer = UO.GetLayer("backpack");
    if (Truth(layer == "Bpack"))
    {
        UO.Print("Player backpack layer");
    }
    else
    {
        UO.Print("Layer: " + layer);
    }

    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. Gestire la mancanza di attrezzature - Classe di script

Parametri e flusso di esecuzione:

  • lastobject deve essere un alias effettivo dell'elemento.
  • Non valido significa livello zero. Ciò di per sé non prova la mancanza dell'oggetto: anche l'oggetto nella borsa non è equipaggiato.
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 layer = UO.GetLayer("lastobject");
        if (Truth(layer == "Invalid"))
        {
            UO.Print("No equipment layer");
        }
        else
        {
            UO.Print("Equipment layer: " + layer);
        }

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

Parametri: Nessun parametro.

Risultato: string / String.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public string GetLayer() => GetLayer(new InjectionValue(bridge.Self));

UO.GetLayer(id) — UO.GetLayer(Any)

Parametri: id (Any)

Risultato: string / String.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public string GetLayer(InjectionValue id) => ConvertLayer(bridge.GetLayer(GetObject(id)));

UO.GetLocked

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

Firme C#

int UO.GetLocked(object? id);

Controlla la paralisi mobile.

Parametri

  • id — 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. L'argomento è obbligatorio; per te, supera self.

Valore restituito

int 1 - caricato mobile ha l'attributo IsParalyzed. int 0 - manca l'attributo, l'oggetto non è mobile, sconosciuto o eliminato. Nonostante il nome Bloccato, non si tratta di una serratura per il torace, di un oggetto protetto o di qualsiasi motivo per non essere in grado di muoversi. Lo stesso flag viene letto come Paralyzed.

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.
  • Nonostante il nome Bloccato, non si tratta di una serratura per il torace, di un oggetto protetto o di qualsiasi motivo per non essere in grado di muoversi. Viene letto lo stesso flag di Paralyzed.

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

1. Controlla il tuo stato - script diretto

Parametri e flusso di esecuzione:

  • L'argomento self seleziona esplicitamente il suo carattere. stato - solo 1/0.
  • Nonostante il nome Bloccato, non si tratta di una serratura per il torace, di un oggetto protetto o di qualsiasi motivo per non essere in grado di muoversi. Viene letto lo stesso flag di Paralyzed.
var state = UO.GetLocked("self");
var paralyzed = UO.Paralyzed();
UO.Print("GetLocked: " + Convert.ToString(state));
UO.Print("Paralyzed: " + Convert.ToString(paralyzed));

2. Controlla la funzione script mobile selezionata

Parametri e flusso di esecuzione:

  • IsNpc esclude soggetto e oggetto sconosciuto. target memorizza un singolo serial anziché un riferimento live a un lasttarget mutevole.
  • Il risultato si riferisce al campo IsParalyzed. I dati vengono aggiornati solo dopo che il client ha ricevuto lo stato appropriato.
return  RunScenario();
 object? RunScenario()
{
    var target = UO.GetSerial("lasttarget");
    if (Truth(UO.IsNPC(target)))
    {
        var state = UO.GetLocked(target);
        UO.Print("Selected mobile state 1/0: " + Convert.ToString(state));
    }
    else
    {
        UO.Print("No loaded mobile selected");
    }

    return null;
}

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

3. Confronta lo stato prima e dopo la pausa: classe di script

Parametri e flusso di esecuzione:

  • UO.Wait(500): pausa in millisecondi. Successivamente, viene controllato separatamente che mobile esista ancora.
  • Vengono confrontate due immagini. Le modifiche intermedie potrebbero non essere perse e questa non è una sottoscrizione continua agli eventi del server.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

    async public Task<object?> RunScenarioAsync()
    {
        var target = UO.GetSerial("lasttarget");
        if (Truth(UO.IsNPC(target)))
        {
            var before = UO.GetLocked(target);
            await Delay(500);
            if (Truth(UO.IsNPC(target)))
            {
                var after = UO.GetLocked(target);
                if (Truth(before != after))
                {
                    UO.Print("Flag changed: " + Convert.ToString(before) + " -> " + Convert.ToString(after));
                }
            }
            else
            {
                UO.Print("Mobile left the local world");
            }
        }

        return null;
    }

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

Implementazione del comando

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

UO.GetLocked(id) — UO.GetLocked(Any)

Parametri: id (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

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

UO.GetName

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

Firme C#

string UO.GetName();
string UO.GetName(object? id);

Legge il nome di un oggetto o di un personaggio noto al client.

Parametri

  • id è il Serial/ID dell'oggetto, non graphic/type. Numero, stringa esadecimale, nome standard self/backpack/lasttarget/lastobject/lastcontainer/laststatus/finditem/lastcorpse o nome AddObject. L'alias deve essere impostato; l'esistenza è controllata da Exists. La forma registrata senza argomenti utilizza self.

Valore restituito

string — nome dell'oggetto. Un oggetto sconosciuto o un nome non ancora ottenuto risultano nella stringa vuota "". Questo non è serial, non type, o l'elenco completo delle proprietà dal tooltip.

Comportamento

  • Vengono letti gli ultimi dati già noti al client; la richiesta di aggiornamento non viene inviata al server.
  • Un oggetto sconosciuto e una proprietà non ancora recuperata possono avere un valore nullo/vuoto. Controlla Exists e le condizioni di una particolare azione.

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

1. Stampa il nome del personaggio - script diretto

Parametri e flusso di esecuzione:

  • Senza argomento, viene utilizzato self.
  • Il risultato è il testo del nome, può essere visualizzato direttamente.
var name = UO.GetName();
UO.Print(name);

2. Nome di destinazione sconosciuto del processo - funzione dello script

Parametri e flusso di esecuzione:

  • lasttarget: alias dell'oggetto. GetName non apre un nuovo target.
  • Un nome vuoto non dimostra l'assenza di un oggetto: l'informazione su serial senza nome potrebbe essere venuta prima.
return  RunScenario();
 object? RunScenario()
{
    var name = UO.GetName("lasttarget");
    if (Truth(name == ""))
    {
        UO.Print("Name is not available");
    }
    else
    {
        UO.Print("Target: " + name);
    }

    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. Confronta il nome senza distinzione tra maiuscole e minuscole - classe di script

Parametri e flusso di esecuzione:

  • ToLowerInvariant converte la stringa in minuscolo per il confronto.
  • Il nome viene impostato dal server e può essere localizzato. Per filtrare per tipo grafico, utilizzare FindType/GetGraphic.
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 name = UO.GetName("lastobject");
        if (Truth(Convert.ToString(name) == "gold"))
        {
            UO.Print("Known name matches");
        }

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

Parametri: Nessun parametro.

Risultato: string / String.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public string GetName() => GetName("self");

UO.GetName(id) — UO.GetName(Any)

Parametri: id (Any/Integer/String)

Risultato: string / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "getname":

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

UO.GetName(id) — UO.GetName(Integer)

Parametri: id (Any/Integer/String)

Risultato: string / String.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public string GetName(int id) => bridge.GetName(id);

UO.GetName(id) — UO.GetName(String)

Parametri: id (Any/Integer/String)

Risultato: string / String.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public string GetName(string id) => GetName(GetObject(id));

UO.GetQuantity

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

Firme C#

int UO.GetQuantity(object? id);

Legge il numero di unità in una pila di articoli.

Parametri

  • id è il Serial/ID dell'oggetto, non graphic/type. Numero, stringa esadecimale, nome standard self/backpack/lasttarget/lastobject/lastcontainer/laststatus/finditem/lastcorpse o nome AddObject. L'alias deve essere impostato; l'esistenza è controllata da Exists. La forma registrata senza argomenti utilizza self. Per questo comando è richiesto l'ID.

Valore restituito

int - Campo importo di un articolo specifico. Uno stack di unità 1000 restituisce tipicamente 1000; elemento singolo - 1. Per l'ignoto serial e per il personaggio ritorna 0. Questo non è il numero di oggetti secondari del baule e non il limite di oggetti del comando MassMove.

Comportamento

  • Vengono letti gli ultimi dati già noti al client; la richiesta di aggiornamento non viene inviata al server.
  • Un oggetto sconosciuto e una proprietà non ancora recuperata possono avere un valore nullo/vuoto. Controlla Exists e le condizioni di una particolare azione.

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

1. Visualizza la dimensione dello stack trovato - script diretto

Parametri e flusso di esecuzione:

  • FindType sta cercando type oro di qualsiasi colore nello zaino.
  • l'oro contiene uno serial, quindi l'importo si applica solo a uno stack trovato.
var gold = UO.FindType(0x0EED, -1, "backpack");
if (Truth(gold != ""))
{
    var amount = UO.GetQuantity(gold);
    UO.Print("Units in this stack: " + Convert.ToString(amount));
}

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

2. Controlla la quantità minima - funzione script

Parametri e flusso di esecuzione:

  • id=sample - ultimo oggetto utilizzato.
  • 50 significa quelli nello stack indicato. 50 I singoli articoli non vengono conteggiati qui.
return  RunScenario();
 object? RunScenario()
{
    var sample = UO.GetSerial("lastobject");
    if (Truth(UO.Exists(sample)))
    {
        if (Truth(UO.GetQuantity(sample) >= 50))
        {
            UO.Print("At least 50 units in this item");
        }
    }

    return null;
}

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

3. Distinguere il numero di pile da quelli: classe dello scenario

Parametri e flusso di esecuzione:

  • FindCount si riferisce ai risultati dell'ultima ricerca; GetQuantity - a uno serial.
  • I numeri possono variare notevolmente. MassMove la quantità limita interi articoli, comprese le pile.
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.FindType(0x0EED, -1, "backpack");
        var stacks = UO.FindCount();
        if (Truth(item != ""))
        {
            var units = UO.GetQuantity(item);
            UO.Print("Matching items: " + Convert.ToString(stacks));
            UO.Print("Units in selected item: " + Convert.ToString(units));
        }

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

Parametri: id (Any/Integer/String)

Risultato: int / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "getquantity": return new InjectionValue(bridge.GetQuantity(Arg(0)));

UO.GetQuantity(id) — UO.GetQuantity(Integer)

Parametri: id (Any/Integer/String)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

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

UO.GetQuantity(id) — UO.GetQuantity(String)

Parametri: id (Any/Integer/String)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

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

UO.GetSerial

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

Firme C#

string UO.GetSerial();
string UO.GetSerial(object? id);

Risolve il nome dell'oggetto nel suo serial e formatta serial come una stringa esadecimale.

Parametri

  • id - Stringa opzionale: alias standard, nome AddObject o testo numerico (decimale/esadecimale). Senza argomento, viene utilizzato serial del carattere corrente.

Valore restituito

string della forma "0x40001234" è un oggetto serial/ID univoco, otto cifre esadecimali dopo 0x. Il nome non risolto dà "0x00000000". Questo non è type. Il testo numerico viene formattato anche se non viene caricato alcun oggetto di questo tipo; GetSerial non controlla Exists.

Comportamento

  • I nomi degli alias vengono letti dallo stato corrente dello script/client. La stringa salvata serial non cambia automaticamente se l'alias punta successivamente a un oggetto diverso.

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

1. Ottieni ID del tuo personaggio - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Non ci sono parametri, è selezionato self.
  • serial – stringa esadecimale. Il valore 0x00000000 significa nessun carattere serial.
var serial = UO.GetSerial();
UO.Print(serial);

2. Utilizza in modo sicuro il cognome selezionato - Funzione script

Parametri e flusso di esecuzione:

  • id="lasttarget" si risolve nell'ultimo bersaglio serial.
  • Exists verifica la presenza dell'oggetto, GetName legge il suo nome noto al client.
return  RunScenario();
 object? RunScenario()
{
    var serial = UO.GetSerial("lasttarget");
    if (Truth(UO.Exists(serial)))
    {
        UO.Print(UO.GetName(serial));
    }
    else
    {
        UO.Print("Target is not loaded");
    }

    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. Confronta rappresentazioni numeriche - Classe di script

Parametri e flusso di esecuzione:

  • id è una stringa con decimale serial 1073746484.
  • Il risultato 0x40001234 mostra la formattazione. Questo è un esempio di numero, non crea un oggetto e non ne garantisce l'esistenza.
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 serial = UO.GetSerial("1073746484");
        UO.Print(serial);
        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.GetSerial() — UO.GetSerial()

Parametri: Nessun parametro.

Risultato: string / String.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public string GetSerial() => NumberConversions.ToHex(bridge.Self);

UO.GetSerial(id) — UO.GetSerial(String)

Parametri: id (String)

Risultato: string / String.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public string GetSerial(string id) => NumberConversions.ToHex(GetObject(id));

UO.GetTooltip

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

Firme C#

dynamic UO.GetTooltip(object? objID);

Legge il testo delle proprietà dell'oggetto finito da OPL. GetTooltip e GetCliloc sono sinonimi.

Parametri

  • objID — Richiesto l'oggetto serial/ID, non type e non cliloc. Accetta int, stringa decimale/esadecimale, self, backpack, lasttarget, trovaelemento o nome AddObject. 0 significa nessun oggetto.

Valore restituito

string — nome e testo delle proprietà, separati da avanzamento riga, o solo la parte non vuota. Stringa vuota se ObjID=0 o se le proprietà non vengono ricevute. Questo è un testo già pronto; numerico ID cliloc e i parametri vengono restituiti da GetTooltipRec.

Comportamento

  • Se la voce esiste già in OPL, il suo testo viene restituito immediatamente. Se non è presente alcuna voce, viene inviata una richiesta di proprietà e è prevista una risposta fino a 200 ms con un controllo ogni 10 ms. Una pausa non garantisce una risposta.
  • Abbiamo bisogno di un oggetto accessibile e del supporto per le proprietà da parte del server. Un risultato vuoto non è una prova che l'oggetto non esiste: utilizzare Exists separatamente.
  • Il testo può contenere markup del server. Non analizzare le proprietà numeriche in base alla posizione della riga; usa GetTooltipRec per questo.

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

1. Proprietà dell'oggetto nello zaino: sceneggiatura diretta

Parametri e flusso di esecuzione:

  • FindType: oro 0x0EED, qualsiasi hue=-1, contenuto diretto backpack. ObjID=oggetto - trovato serial.
  • Il risultato getter è il testo, non la quantità di oro. Per la quantità utilizzare FindCount(articolo).
var item = UO.FindType(0x0EED, -1, "backpack");
if (Truth(item != ""))
{
    UO.Print(UO.GetTooltip(item));
}

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

2. Gestisci nessuna risposta - Funzione script

Parametri e flusso di esecuzione:

  • ObjID=lasttarget deve puntare all'oggetto desiderato.
  • Una stringa vuota viene elaborata separatamente; Non è necessario ripetere automaticamente la richiesta in un ciclo infinito.
return  RunScenario();
 object? RunScenario()
{
    var text = UO.GetTooltip("lasttarget");
    if (Truth(text == ""))
    {
        UO.Print("No properties received");
    }
    else
    {
        UO.Print(text);
    }

    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. Salva il testo fino all'azione successiva: classe di script

Parametri e flusso di esecuzione:

  • id e salvato sono variabili separate: l'univoco ID dell'oggetto e un'istantanea del suo testo.
  • salvato non cambierà automaticamente se le proprietà sul server cambiano successivamente.
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");
        var saved = UO.GetTooltip(id);
        UO.Print("Object: 0x" + Hex(id));
        UO.Print(saved);
        return null;
    }

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

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

Parametri: objID (Any)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "getcliloc":

                case "gettooltip":

                    return new InjectionValue(bridge.GetTooltip(Arg(0)));

UO.GetTooltipRec

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

Firme C#

dynamic UO.GetTooltipRec(object? objID);

Legge le proprietà strutturate: cliloc ID e i parametri di ciascuna voce OPL.

Parametri

  • objID — Richiesto l'oggetto serial/ID, non type e non cliloc. Accetta int, stringa decimale/esadecimale, self, backpack, lasttarget, trovaelemento o nome AddObject. 0 significa nessun oggetto.

Valore restituito

Array è un singolo snapshot di righe di proprietà. Ogni riga è uguale a [clilocID:int, parametri:Array]. righe[i][0] è il numero del messaggio localizzato, righe[i][1] è un array di parametri. ArrayLength(righe) — numero di proprietà; ArrayLength(parametri) — il numero di parametri per una proprietà. Un array vuoto se ObjID=0 o nessun record ricevuto. Questo non è un elenco di elementi ID o un testo finito.

Comportamento

  • La voce della cache viene restituita immediatamente. Se manca OPL, le proprietà vengono interrogate con un'attesa fino a 120 ms; annullando la procedura si interrompe l'attesa. Il noto vuoto OPL non provoca anticipazione.
  • Le schede di servizio iniziali vengono saltate come in ClilocLoader. I parametri interni vuoti salvano le posizioni; #Il numero viene salvato come stringa per la successiva localizzazione. I parametri sconosciuti producono un array vuoto.
  • La modifica dell'array restituito non modifica la cache del client. Per il testo utilizzare GetTooltip/GetCliloc; per tradurre una riga - GetClilocByID(clilocID, parametri).

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

1. Visualizza tutti i numeri delle proprietà - script diretto

Parametri e flusso di esecuzione:

  • ObjID=lasttarget — oggetto. righe contiene proprietà, i è l'indice da 0. row[0] è cliloc, non serial.
  • Il ciclo fallisce su un array vuoto. Ogni record viene elaborato una volta.
var rows = UO.GetTooltipRec("lasttarget");
var i = 0;
while (Truth(i < ArrayLength(rows)))
{
    var row = rows[i];
    UO.Print("Cliloc: " + Convert.ToString(row[0]));
    i = i + 1;
}

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;

2. Traduci ogni record con i suoi parametri - funzione script

Parametri e flusso di esecuzione:

  • GetClilocByID riceve clilocID=riga[0] e matrice di sostituzione=riga[1].
  • I parametri sono mantenuti in ordine. Non passare l'intera riga invece di un array di parametri.
return  RunScenario();
 object? RunScenario()
{
    var rows = UO.GetTooltipRec("lasttarget");
    var i = 0;
    while (Truth(i < ArrayLength(rows)))
    {
        var row = rows[i];
        var text = UO.GetClilocByID(row[0], row[1]);
        UO.Print(text);
        i = i + 1;
    }

    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;

3. Ottieni il parametro numerico di una proprietà nota: classe di script

Parametri e flusso di esecuzione:

  • voluto - esempio di proprietà ID; sostituire con il cliloc desiderato. args[0] è il primo parametro, inizialmente string.
  • Il numero di parametri e il formato numerico vengono controllati prima di Val. Il parametro può essere testo o un collegamento #cliloc.
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 rows = UO.GetTooltipRec("lasttarget");
        var wanted = 1060401;
        var i = 0;
        while (Truth(i < ArrayLength(rows)))
        {
            var row = rows[i];
            var args = row[1];
            if (Truth(row[0] == wanted) && Truth(ArrayLength(args) > 0))
            {
                if (Truth(IsNumeric(args[0])))
                {
                    UO.Print("Value: " + Convert.ToString(Val(args[0])));
                }
            }

            i = i + 1;
        }

        return null;
    }

    int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
    bool IsNumeric(object? value) => double.TryParse(Convert.ToString(value), System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out _);
    bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
    double Val(object? value) => double.TryParse(Convert.ToString(value), System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out var number) ? number : 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.GetTooltipRec(objID) — UO.GetTooltipRec(Any)

Parametri: objID (Any)

Risultato: dynamic / Array.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "gettooltiprec":

                    return new InjectionValue(bridge.GetTooltipRecords(Arg(0)).Select(entry =>

                        new InjectionValue(new[]

                        {

                            new InjectionValue(entry.ClilocID),

                            new InjectionValue(entry.Parameters.Select(value => new InjectionValue(value)).ToArray())

                        })).ToArray());

UO.GetType

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

Firme C#

dynamic UO.GetType(object? objID);

Legge il numerico graphic di un elemento o body di un carattere.

Parametri

Valore restituito

int - graphic/type di un oggetto o body di un personaggio, ad esempio 0x0EED (3821) per l'oro. Se l'oggetto non viene trovato viene restituito il valore 0. GetType non restituisce serial né il testo "0x..."; la forma della stringa è data da GetGraphic.

Comportamento

  • Il comando legge i dati locali del client. Non invia target e non modifica l'oggetto sul server.
  • Il numero 0 può essere un valore di dati valido. Verifica l'assenza di un oggetto tramite Exists(serial) e non solo tramite il valore della sua proprietà.

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

1. Confronta il numerico type con una costante - scrittura diretta

Parametri e flusso di esecuzione:

  • ObjID="lastobject" - alias di un oggetto specifico.
  • 0x0EED è il numero di graphic; Il confronto non cerca un oggetto con tale serial.
var graphic = UO.GetType("lastobject");
if (Truth(graphic == 0x0EED))
{
    UO.Print("Gold graphic");
}

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

2. Ottieni il tuo zaino type - funzione script

Parametri e flusso di esecuzione:

  • ObjID="backpack" - zaino attuale.
  • Convert.ToString formatta il numero restituito per l'output.
return  RunScenario();
 object? RunScenario()
{
    var graphic = UO.GetType("backpack");
    UO.Print("Backpack type: " + Convert.ToString(graphic));
    return null;
}

3. Controlla l'esistenza dell'oggetto prima di leggere type - classe script

Parametri e flusso di esecuzione:

  • La stringa vuota FindType viene controllata prima di Exists.
  • Exists restituisce il valore booleano 1/0; GetType restituisce il numero graphic.
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.FindType(0x0EED, -1, "backpack");
        if (Truth(item != ""))
        {
            if (Truth(UO.Exists(item)))
            {
                UO.Print("Type: " + Convert.ToString(UO.GetType(item)));
            }
        }

        return null;
    }

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

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

Parametri: objID (Any)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "gettype": return new InjectionValue(bridge.GetGraphics(Arg(0)));

UO.Grab

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

Firme C#

int UO.Grab();
int UO.Grab(object? id);
int UO.Grab(object? amount, object? id);
int UO.Grab(object? amount, object? item, object? container);
int UO.Grab(object? amount, object? item, object? container, object? timeout);

Trasferisce un articolo nel contenitore specificato/ricevente oppure apre la selezione degli articoli.

Parametri

  • id — Seriale/alias dell'articolo. Senza argomenti inizia la selezione interattiva; con un argomento esattamente 1 viene presa l'unità di questo elemento.
  • item — Seriale/alias dell'articolo. Senza argomenti inizia la selezione interattiva; con un argomento esattamente 1 viene presa l'unità di questo elemento.
  • id / item — Seriale/alias dell'articolo. Senza argomenti inizia la selezione interattiva; con un argomento esattamente 1 viene presa l'unità di questo elemento.
  • amount - Nei moduli 2..4 - quantità come primo argomento, poi articolo. 0 significa l'intero stack secondo le regole MoveItem; non modificare l'ordine con il modulo Grab(item).
  • container - Solo moduli 3/4: assegnazione esplicita. Senza di esso - stato.ReceivingContainer, se >0, altrimenti backpack. Le linee self/my/backpack nella destinazione significano zaino; ground - terra.
  • Solo forma timeout - 4, millisecondi. Inviato a CompactMoveItem in attesa di conferma; le coordinate ground sono prese da self, contenitore - 0xFFFF/0xFFFF/0.

Valore restituito

Flag numerico int: 1 — selezione interattiva accettata, oppure trasferimento accettato/confermato a seconda del modulo selezionato; 0 - guasto/articolo non adatto. Un risultato senza argomenti non significa che l'elemento è già stato trasferito.

Comportamento

  • CompactGrab mantiene la forma storica Grab(item)=1 unità. I moduli senza timeout utilizzano CompactMoveItem senza forzare un'attesa di conferma; il modulo con timeout specifica UO.Wait=true.
  • Il seriale 0 dà immediatamente 0. Gli oggetti non risolti/inappropriati vengono ulteriormente controllati da MoveItem. Le regole del server, la quantità di stack e il contenitore corrente influiscono sul risultato. Tre/quattro argomenti non sono coordinate di rilascio.
  • amount<=0 richiede l'intero stack. In un modulo con timeout, la pausa negativa diventa 0, ma viene effettuato almeno un controllo locale; tra i controlli UO.Wait(10). Il trasferimento parziale è confermato dalla diminuzione della quantità iniziale, il trasferimento completo è confermato dall'assegnazione e per ground X/Y/Z. Questa è un'osservazione dello stato del mondo, non una nuova risposta di protocollo dalla richiesta ID; uno stato già idoneo può dare 1 immediatamente. Il timeout dà 0 anche se la richiesta potrebbe essere già stata inviata.

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Trasferisce un articolo nel contenitore specificato/ricevente oppure apre la selezione degli articoli.
var accepted = UO.Grab();
UO.Print(accepted);

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • CompactGrab mantiene la forma storica Grab(item)=1 unità. I moduli senza timeout utilizzano CompactMoveItem senza forzare un'attesa di conferma; il modulo con timeout specifica UO.Wait=true.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Exists("lastobject")))
    {
        UO.Print(UO.Grab("lastobject"));
    }

    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:

  • Il seriale 0 dà immediatamente 0. Gli oggetti non risolti/inappropriati vengono ulteriormente controllati da MoveItem. Le regole del server, la quantità di stack e il contenitore corrente influiscono sul risultato. Tre/quattro argomenti non sono coordinate di rilascio.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        if (Truth(UO.Exists("lastobject")))
        {
            UO.Print(UO.Grab(0, "lastobject", "backpack", 2000));
        }

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

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int Grab() => bridge.RequestInteractiveGrabTarget();

UO.Grab(id) — UO.Grab(Any)

Parametri: id (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int Grab(InjectionValue id) => CompactGrab(new[] { id });

UO.Grab(amount, id) — UO.Grab(Any,Any)

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

Risultato: int / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "grab": return new InjectionValue(CompactGrab(arguments));

UO.Grab(amount, id) — UO.Grab(Integer,Integer)

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

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int Grab(int amount, int id) => CompactGrab(new[] { new InjectionValue(amount), new InjectionValue(id) });

UO.Grab(amount, id) — UO.Grab(Integer,String)

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

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int Grab(int amount, string id) => CompactGrab(new[] { new InjectionValue(amount), new InjectionValue(id) });

UO.Grab(amount, id) — UO.Grab(String,String)

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

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int Grab(string amount, string id) => CompactGrab(new[] { new InjectionValue(amount), new InjectionValue(id) });

UO.Grab(amount, item, container) — UO.Grab(Any,Any,Any)

Parametri: amount (Any), item (Any), container (Any)

Risultato: int / Integer.

Durante la chiamata:

La chiamata esegue il delegate del gestore memorizzato. Il metodo di registrazione lo crea durante la costruzione dell’API.

Codice interno di implementazione; non è uno script autonomo.

values => new InjectionValue(CompactGrab(values))

UO.Grab(amount, item, container, timeout) — UO.Grab(Any,Any,Any,Any)

Parametri: amount (Any), item (Any), container (Any), timeout (Any)

Risultato: int / Integer.

Durante la chiamata:

La chiamata esegue il delegate del gestore memorizzato. Il metodo di registrazione lo crea durante la costruzione dell’API.

Codice interno di implementazione; non è uno script autonomo.

values => new InjectionValue(CompactGrab(values))

UO.IsMovable

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

Firme C#

int UO.IsMovable(object? objID);

Controlla i segni locali di portabilità di un oggetto noto utilizzando le regole di selezione Classic UO.

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 - l'oggetto non viene rimosso, non è multiplo e non è bloccato dalla regola locale di peso/spostamento per gli oggetti a terra. int 0 — oggetto mobile, multiplo, sconosciuto/rimosso o oggetto bloccato a terra. 1 non garantisce il successo del Drag/MoveItem: l'intervallo, l'accesso, lo stato del cursore e la decisione finale del server vengono controllati separatamente.

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.
  • A terra, un oggetto è considerato bloccato quando il peso della sua voce Tiledata è maggiore di 90 e manca il flag del server mobile. I pesi 90 e inferiori non richiedono questo flag.
  • All'interno di un container non vale la regola di bloccare un oggetto a terra. Il peso dei Tiledata qui è un attributo del servizio, non GetQuantity e non il peso attuale del carattere.
  • Altra documentazione del cliente potrebbe avere descrizioni di peso diverse. La regola effettiva di questo client GameActions.PickUp è descritta qui.

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

1. Controlla l'ultimo elemento senza muoverti - script diretto

Parametri e flusso di esecuzione:

  • oggetto — serial dell'ultimo oggetto utilizzato. Il numero dei mobili non è la sua quantità.
  • L'esempio non preleva nulla e non invia nulla al server.
var item = UO.GetSerial("lastobject");
var movable = UO.IsMovable(item);
UO.Print("Locally movable 1/0: " + Convert.ToString(movable));

2. Stimare separatamente il segno e la distanza - funzione script

Parametri e flusso di esecuzione:

  • Per un oggetto a terra, GetDistance mostra la portata nota del cliente.
  • Anche con mobile=1 l'oggetto potrebbe essere troppo lontano. Un risultato positivo non indica l'autorizzazione del server al trasferimento.
return  RunScenario();
 object? RunScenario()
{
    var item = UO.GetSerial("lasttarget");
    if (Truth(UO.Exists(item)))
    {
        var movable = UO.IsMovable(item);
        var distance = UO.GetDistance(item);
        UO.Print("Movable: " + Convert.ToString(movable));
        UO.Print("Distance: " + Convert.ToString(distance));
    }

    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'intero stack trovato - classe di script

Parametri e flusso di esecuzione:

  • FindType seleziona un serial oro di qualsiasi colore nello zaino.
  • IsMovable controlla l'intero articolo. GetQuantity legge separatamente il numero di unità; il risultato IsMovable non sostituisce questo contatore.
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.FindType(0x0EED, -1, "backpack");
        if (Truth(item != ""))
        {
            if (Truth(UO.IsMovable(item)))
            {
                var units = UO.GetQuantity(item);
                UO.Print("Selected stack units: " + Convert.ToString(units));
            }
        }

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

Parametri: objID (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "ismovable": return new InjectionValue(bridge.IsMovable(Arg(0)));

UO.IsObjectExists

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

Firme C#

int UO.IsObjectExists(object? objID);

Verifica la presenza di un oggetto non eliminato nel mondo locale del client.

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 - serial ora si risolve nell'oggetto caricato o mobile. int 0 - l'oggetto è sconosciuto al client, cancellato o l'alias non è impostato. Questa non è una risposta del server sull'esistenza di un oggetto: un elemento al di fuori dell'area visibile può esistere sul server e fornire qui 0.

Il risultato del comando è un flag numerico: 1 significa una condizione soddisfatta, 0 significa una condizione non soddisfatta. Dopo var risultato = comando(...) controlla se (risultato != 0) o se (risultato == 0). Salva il risultato di una chiamata: una chiamata ripetuta può eseguire nuovamente l'azione o leggere lo stato che è già cambiato.

Comportamento

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

1. Controlla se lo zaino è disponibile - script diretto

Parametri e flusso di esecuzione:

  • L'argomento backpack è un alias serial dello zaino del tuo personaggio.
  • 1 non significa che il contenuto dello zaino sia già stato completamente ricevuto o che sia stato aperto.
var present = UO.IsObjectExists("backpack");
if (Truth(present))
{
    UO.Print("Backpack is loaded");
}
else
{
    UO.Print("Backpack is unavailable");
}

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

2. Ricontrolla la funzione salvata serial - script

Parametri e flusso di esecuzione:

  • target memorizza lo specifico serial. Il nuovo valore lasttarget non lo sostituirà.
  • Dopo la pausa 500 ms, l'oggetto potrebbe non essere più visibile, quindi il controllo viene eseguito nuovamente.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var target = UO.GetSerial("lasttarget");
    await Delay(500);
    if (Truth(UO.IsObjectExists(target)))
    {
        UO.Print(UO.GetName(target));
    }
    else
    {
        UO.Print("Saved target is no longer loaded");
    }

    return null;
}

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

3. Distinguere la formattazione ID dalla presenza dell'oggetto - classe script

Parametri e flusso di esecuzione:

  • GetSerial formatta il numero 1073746484 come 0x40001234 anche se non è presente alcun oggetto.
  • Solo il controllo successivo riporta la presenza di questo serial nell'attuale mondo locale.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var serial = UO.GetSerial("1073746484");
        UO.Print("Serial: " + serial);
        var present = UO.IsObjectExists(serial);
        UO.Print("Present 1/0: " + Convert.ToString(present));
        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.IsObjectExists(objID) — UO.IsObjectExists(Any)

Parametri: objID (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "isobjectexists": return new InjectionValue(bridge.Exists(Arg(0)));

UO.LastObject

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

Firme C#

dynamic UO.LastObject();

Legge serial dell'ultimo oggetto utilizzato.

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.LastObject. 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.LastObject();
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 oggetto utilizzato.
var id = UO.LastObject();
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.LastObject. Il comando non seleziona, utilizza o attacca l'oggetto.
return  RunScenario();
 object? RunScenario()
{
    var id = UO.LastObject();
    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.LastObject();
        UO.Wait(500);
        var after = UO.LastObject();
        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.LastObject() — UO.LastObject()

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "lastobject": return new InjectionValue(bridge.GetLastObject());

UO.MakeFakeItem

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

Firme C#

void UO.MakeFakeItem(object? @type);
void UO.MakeFakeItem(object? @type, object? serial);
void UO.MakeFakeItem(object? @type, object? serial, object? count);
void UO.MakeFakeItem(object? @type, object? serial, object? count, object? color);
void UO.MakeFakeItem(object? @type, object? serial, object? count, object? color, object? x);
void UO.MakeFakeItem(object? @type, object? serial, object? count, object? color, object? x, object? y);

Crea o modifica solo un elemento client locale.

Parametri

  • type - Obbligatorio graphic 1..65535; senza nome da type a ResolveType: questo ramo legacy utilizza Arg/int.
  • serial - Elemento serial opzionale. 0 (default) assegna un ID libero dall'intervallo locale attorno a 0x7FFEFFFF; un elemento esplicito serial può corrispondere a un elemento già caricato e modificarne il modello locale.
  • count - Quantità opzionale, predefinita 1. Il non positivo diventa 1; massimo 65535.
  • color - Opzionale hue, predefinito 0; limitato a 0..65535.
  • x - Coordinate mondiali opzionali, per impostazione predefinita sono self; quelli negativi usano self, quindi si limitano a 0..65535. Z è sempre il Player.Z corrente.
  • y - Coordinate mondiali opzionali, per impostazione predefinita sono self; quelli negativi usano self, quindi si limitano a 0..65535. Z è sempre il Player.Z corrente.

Valore restituito

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

Comportamento

  • CreateFakeItem richiede Giocatore e graphic/oggetto serial valido. GetOrCreateItem restituisce il modello locale; se è in un contenitore, elimina la connessione. Assegna ground contenitore 0xFFFFFFFF, graphic/importo/hue/X/Y/Z, Layer.Invalid, AllowedToDraw=true, IsDamageable=false e IsMulti=false.
  • Il comando Legacy scarta il serial restituito. Quando 0 visualizza un messaggio di errore. Il server non crea l'oggetto: l'azione non fornisce un oggetto reale, un bottino o diritti di trasferimento. Ad esempio, lascia serial=0.

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.MakeFakeItem");
UO.MakeFakeItem(0x0E21);

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Crea o modifica solo un elemento client locale.
UO.MakeFakeItem(0x0E21);

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • CreateFakeItem richiede Giocatore e graphic/oggetto serial valido. GetOrCreateItem restituisce il modello locale; se è in un contenitore, elimina la connessione. Assegna ground contenitore 0xFFFFFFFF, graphic/importo/hue/X/Y/Z, Layer.Invalid, AllowedToDraw=true, IsDamageable=false e IsMulti=false.
return  RunScenario();
 object? RunScenario()
{
    UO.MakeFakeItem(0x0E21, 0, 5, 0);
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

  • Il comando Legacy scarta il serial restituito. Quando 0 visualizza un messaggio di errore. Il server non crea l'oggetto: l'azione non fornisce un oggetto reale, un bottino o diritti di trasferimento. Ad esempio, lascia serial=0.
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.MakeFakeItem(0x0E21, 0, 1, 0, UO.GetX(), UO.GetY());
        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.MakeFakeItem(type) — UO.MakeFakeItem(Any)

Parametri: type (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "makefakeitem":

                {

                    int graphic = Arg(0);

                    int serial = Arg(1, 0);

                    int amount = Arg(2, 1);

                    int hue = Arg(3, 0);

                    int x = Arg(4, bridge.GetX(bridge.Self));

                    int y = Arg(5, bridge.GetY(bridge.Self));

                    int createdSerial = bridge.CreateFakeItem(graphic, serial, amount, hue, x, y);

                    if (createdSerial == 0)

                        SystemMessage("MakeFakeItem: invalid graphic/serial or no active player.");

                    break;

                }

UO.MakeFakeItem(type, serial) — UO.MakeFakeItem(Any,Any)

Parametri: type (Any), serial (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "makefakeitem":

                {

                    int graphic = Arg(0);

                    int serial = Arg(1, 0);

                    int amount = Arg(2, 1);

                    int hue = Arg(3, 0);

                    int x = Arg(4, bridge.GetX(bridge.Self));

                    int y = Arg(5, bridge.GetY(bridge.Self));

                    int createdSerial = bridge.CreateFakeItem(graphic, serial, amount, hue, x, y);

                    if (createdSerial == 0)

                        SystemMessage("MakeFakeItem: invalid graphic/serial or no active player.");

                    break;

                }

UO.MakeFakeItem(type, serial, count) — UO.MakeFakeItem(Any,Any,Any)

Parametri: type (Any), serial (Any), count (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "makefakeitem":

                {

                    int graphic = Arg(0);

                    int serial = Arg(1, 0);

                    int amount = Arg(2, 1);

                    int hue = Arg(3, 0);

                    int x = Arg(4, bridge.GetX(bridge.Self));

                    int y = Arg(5, bridge.GetY(bridge.Self));

                    int createdSerial = bridge.CreateFakeItem(graphic, serial, amount, hue, x, y);

                    if (createdSerial == 0)

                        SystemMessage("MakeFakeItem: invalid graphic/serial or no active player.");

                    break;

                }

UO.MakeFakeItem(type, serial, count, color) — UO.MakeFakeItem(Any,Any,Any,Any)

Parametri: type (Any), serial (Any), count (Any), color (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "makefakeitem":

                {

                    int graphic = Arg(0);

                    int serial = Arg(1, 0);

                    int amount = Arg(2, 1);

                    int hue = Arg(3, 0);

                    int x = Arg(4, bridge.GetX(bridge.Self));

                    int y = Arg(5, bridge.GetY(bridge.Self));

                    int createdSerial = bridge.CreateFakeItem(graphic, serial, amount, hue, x, y);

                    if (createdSerial == 0)

                        SystemMessage("MakeFakeItem: invalid graphic/serial or no active player.");

                    break;

                }

UO.MakeFakeItem(type, serial, count, color, x) — UO.MakeFakeItem(Any,Any,Any,Any,Any)

Parametri: type (Any), serial (Any), count (Any), color (Any), x (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "makefakeitem":

                {

                    int graphic = Arg(0);

                    int serial = Arg(1, 0);

                    int amount = Arg(2, 1);

                    int hue = Arg(3, 0);

                    int x = Arg(4, bridge.GetX(bridge.Self));

                    int y = Arg(5, bridge.GetY(bridge.Self));

                    int createdSerial = bridge.CreateFakeItem(graphic, serial, amount, hue, x, y);

                    if (createdSerial == 0)

                        SystemMessage("MakeFakeItem: invalid graphic/serial or no active player.");

                    break;

                }

UO.MakeFakeItem(type, serial, count, color, x, y) — UO.MakeFakeItem(Any,Any,Any,Any,Any,Any)

Parametri: type (Any), serial (Any), count (Any), color (Any), x (Any), y (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "makefakeitem":

                {

                    int graphic = Arg(0);

                    int serial = Arg(1, 0);

                    int amount = Arg(2, 1);

                    int hue = Arg(3, 0);

                    int x = Arg(4, bridge.GetX(bridge.Self));

                    int y = Arg(5, bridge.GetY(bridge.Self));

                    int createdSerial = bridge.CreateFakeItem(graphic, serial, amount, hue, x, y);

                    if (createdSerial == 0)

                        SystemMessage("MakeFakeItem: invalid graphic/serial or no active player.");

                    break;

                }

UO.MassMove

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

Firme C#

void UO.MassMove();
void UO.MassMove(object? delay);
void UO.MassMove(object? delay, object? quantity);
void UO.MassMove(object? delay, object? quantity, object? @type);
void UO.MassMove(object? delay, object? quantity, object? @type, object? destination);
void UO.MassMove(object? delay, object? quantity, object? @type, object? destination, object? x, object? y, object? z);

Abilita un trasferimento di massa una tantum di elementi del tipo selezionato. Dopo l'attivazione MassMove trascinare con il mouse un elemento adatto: da questo viene determinato il contenitore di origine. Altri articoli di questo tipo provenienti dalla stessa fonte seguono automaticamente. Il terzo parametro è TYPE/Grafica, non ID dell'elemento. Tutti i moduli prevedono l'attesa del primo bonifico manuale; la destinazione esplicita specifica dove andrà.

Parametri

  • delay — Il primo parametro è il ritardo tra le richieste di trasferimento in millisecondi, un numero intero da 0 a 2147483647. 350 significa 0,35 secondi. Con 0 non viene inviato più di un carry successivo per frame di gioco. Nessun ritardo viene aggiunto a GrabDelay. Un valore negativo disabilita la modalità e cancella la coda; per lo spegnimento è preferibile una chiara notazione UO.MassMove().
  • quantity - Il secondo parametro è il limite TOTALE dei singoli articoli (articoli), compreso il primo trasferimento manuale. Una pila/pila è considerata un articolo, indipendentemente dalla quantità contenuta. 50 significa fino a 50 pile intere o 50 singoli elementi. Lo stack NON viene diviso a questo limite. 0 o nessun parametro: tutti gli elementi adatti. Non sono ammessi valori negativi.
  • type - Il terzo parametro è il codice del tipo di oggetto (Grafico/Tipo), il numero intero 0..65535, ad esempio 0x0EED o la stringa "0x0EED" per l'oro. Questo NON è serial/ID e NON il nome AddObject. 0 o assenza determina la tipologia dal primo trasferimento manuale. Con un tipo esplicito, il trascinamento di un altro tipo non attiva la coda; La modalità continua ad attendere un elemento adatto.
  • destination — Il quarto parametro è lo scopo. Seriale del baule (numero/stringa esadecimale) o nome memorizzato AddObject seleziona il contenitore; X/Y è un posto all'interno della sua finestra. backpack, self e my seleziona lo zaino del personaggio attuale, anche con le coordinate all'interno dello zaino. ground o 0 seleziona il terreno: X/Y/Z - posizione assoluta sulla mappa, sono richiesti tutti e tre i parametri. lastcontainer — ultimo contenitore aperto; lastobject, lasttarget, lastcorpse, finditem, laststatus sono validi se puntano a un contenitore disponibile. receiving e catchbag seleziona il contenitore SetCatchBag installato e, se non è installato, lo zaino. self/my qui significa lo zaino, anche se GetX(self) legge la posizione del personaggio. I nomi vengono confrontati senza distinzione tra maiuscole e minuscole; un nome sconosciuto o non ancora impostato dà errore anziché far cadere l'oggetto a terra. Senza destinazione, la posizione viene ricordata dal primo reset manuale: è possibile posizionare il campione sia all'interno del contenitore che a terra. Per la terra viene ricordato il mondo X/Y/Z del primo reset.
  • x — Quinto parametro. Per un contenitore, le coordinate all'interno del contenitore; -1 o 65535 significa posizionamento automatico. Per la terra, la coordinata assoluta della mappa, da 0 a 65535. Per una forma senza X/Y/Z, -1 viene utilizzato in un contenitore esplicito.
  • y — Sesto parametro. Per un contenitore: le coordinate all'interno del contenitore, -1/65535 per il posizionamento automatico; per il suolo - la coordinata assoluta della mappa 0..65535. Per un modulo senza coordinate in un contenitore esplicito, utilizzare -1.
  • z — Il settimo parametro è l'altezza di destinazione, intero -128..127. Il contenitore solitamente contiene 0; a terra indicano l'altezza effettiva. Nella forma abbreviata, l'altezza e X/Y vengono ricavate dal trasferimento manuale.

Valore restituito

void: nessun valore. Attivare MassMove significa abilitare l'attesa del trasferimento manuale. La riga del totale riporta il numero dei singoli articoli per i quali sono state inviate le richieste, compreso il primo. Una pila è considerata un elemento; il risultato non conferma l'accettazione di ciascuna richiesta da parte del server.

Comportamento

  • Vengono registrati i moduli con argomenti 0, 1, 2, 3, 4 e 7. X/Y/Z sono specificati solo insieme. I moduli con argomenti 5, 6 o 8 non sono supportati. Ordine: ritardo, quantità, type, destinazione, x, y, z.
  • Attiva la modalità di acquisizione PRIMA del mouse. Il primo trasferimento manuale è considerato un elemento: lo stack da 1000 viene trasferito interamente e consuma solo uno spazio dal limite 50. La modalità abilitata accetta stack completi senza una finestra di dialogo divisa. Se parte della pila è stata prelevata prima dell'inclusione, il trasferimento viene rifiutato: rimettere a posto la parte e ricominciare.
  • Un'attivazione si riferisce ad un trasferimento manuale. Dopo aver selezionato un campione, la modalità di selezione si disattiva; la coda rimanente viene elaborata automaticamente. Una normale chiamata a MoveItem da un altro script non conta come selezione manuale del campione.
  • Viene confrontato il tipo Grafico. Il colore non viene filtrato in questo comando. Vengono elaborati solo i contenuti diretti del contenitore di origine; Le buste incluse non si aprono. I nuovi elementi visualizzati dopo la creazione della coda non vengono aggiunti ad essa. Se il campione giaceva a terra, vengono presi in considerazione gli oggetti caricati dello stesso tipo nel raggio di cattura.
  • La quantità è il limite massimo delle richieste. Il comando non ritenta automaticamente i trasferimenti rifiutati dal server. Se il server fallisce, la destinazione non è disponibile, il personaggio muore o non è possibile prendere l'oggetto successivo, l'operazione viene interrotta. Quando il cursore è occupato, la coda attende fino a 5 secondi per liberarsi.
  • UO.MassMove() disattiva la modalità e annulla la coda rimanente. UO.TerminateAll() e lasciando il carattere lo cancellano anche. Una richiesta già inviata non viene annullata mediante annullamento. La coda viene eseguita dal client dopo la restituzione del comando; la riga successiva dello script non significa che il server abbia già completato il trasferimento.
  • Per migrare completamente diversi tipi di contenuto, utilizzare EmptyContainer. Per trasportare un oggetto specifico - MoveItem. Gli otto argomenti source, type, color, Destination, x, y, z, delay si riferiscono a MoveItems, non a MassMove.
  • Richiamare correttamente lo stesso comando ripetutamente, mentre la modalità è ancora in attesa del primo trascinamento del mouse, disattiva l'attesa: Disattiva MassMove/MassPriceMove appare direttamente nella finestra di gioco. La chiamata successiva riattiva la modalità. Dopo il primo trasferimento, utilizza il modulo senza argomenti per interrompere la coda rimanente. Le richieste già inviate non vengono annullate.

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.MassMove");
UO.MassMove(350, 0);

1. Abilita il trasferimento del mouse senza limitare il numero - script diretto

Parametri e flusso di esecuzione:

  • ritardo=350: le richieste successive sono separate da almeno 350 ms. quantità=0: non esiste un limite utente superiore.
  • type, destinazione e X/Y/Z non vengono trasmessi. Dopo l'attivazione MassMove, trascina il campione dalla borsa al baule: il tipo e la fonte vengono presi da esso, la destinazione è dal luogo di rilascio.
  • Se il campione è oro, vengono spostate le pile d'oro caricate dello stesso contenitore originale. Rimangono elementi di altro tipo. Print spiega solo la successiva azione manuale.
UO.MassMove(350, 0);
UO.Print("Drag one sample item to the destination container");

2. Trasferisci 50 interi stack da 100 - funzione script

Parametri e flusso di esecuzione:

  • il ritardo imposta 350 ms. il totale viene passato al secondo parametro quantità e limita l'INTERA operazione 50 ai singoli articoli.
  • Se la sorgente contiene 100 stack dello stesso tipo, verranno trasferiti 50 interi stack: il primo manuale uno e l'altro 49. Ogni pila può contenere un importo diverso; non influenza il contatore. Se si tratta di elementi singoli, vengono trasferiti elementi singoli 50.
  • Non ci sono altre opzioni: la prima cattura e assegnazione vengono selezionate con il mouse dopo la chiamata.
return  RunScenario();
 object? RunScenario()
{
    var delay = 350;
    var total = 50;
    UO.MassMove(delay, total);
    return null;
}

3. Seleziona il tipo di oro e imposta il forziere in anticipo - classe dello scenario

Parametri e flusso di esecuzione:

  • goldType - TYPE oro, non ID uno stack separato. AddObject salva serial del forziere nel petto; sostituisci 0x40005678 con il tuo ID.
  • ritardo=350 ms, quantità=50 singoli articoli, type=0x0EED, destinazione=cassa. Il limite comprende la prima pila e non più di 49; il tutto.
  • x=-1 e y=-1 impostano il posizionamento automatico nel petto, z=0. Questi sono tutti e sette i parametri.
  • La coda inizierà dopo aver trascinato manualmente l'oro. La sua borsa originale diventerà la fonte. Una cassa esplicita sostituisce la posizione di ripristino del mouse; un elemento di altro tipo non avvia la coda.
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 goldType = "0x0EED";
        UO.AddObject("chest", "0x40005678");
        UO.MassMove(350, 50, goldType, "chest", -1, -1, 0);
        UO.Print("Now drag one gold stack from the source bag");
        return null;
    }
}

4. Seleziona un campione con il mouse, ma prepara il terreno in anticipo - script diretto

Parametri e flusso di esecuzione:

  • ritardo=350 ms, quantità=0 — tutti gli articoli adatti. type=0 prende il tipo dal futuro trasferimento manuale.
  • destinazione=0 significa terra, quindi viene data la terna intera x,y,z. GetX/GetY/GetZ qui restituisce la posizione corrente del personaggio.
  • Dopo aver chiamato, prendi e rilascia il campione con il mouse. Il comando lo invierà e altri elementi corrispondenti alle coordinate specificate, anche se il mouse si trovava sopra il contenitore. Il server controlla la disponibilità del terreno.
var x = UO.GetX();
var y = UO.GetY();
var z = UO.GetZ();
UO.MassMove(350, 0, 0, 0, x, y, z);

5. Sposta fino a dieci oggetti di un tipo noto in uno zaino - funzione script

Parametri e flusso di esecuzione:

  • ritardo=500 — mezzo secondo; quantità=10 - dieci singoli articoli/pile per l'intera operazione.
  • type=0x0F7A — tipo grafico dell'articolo. Per favore indica la tua tipologia; il numero di serie del modulo 0x40001234 non è consentito qui.
  • destinazione=backpack — zaino del personaggio. Le coordinate non vengono trasmesse, quindi al suo interno vengono utilizzati x=-1, y=-1, z=0.
  • La fonte viene selezionata trasferendo prima manualmente un elemento adatto. Se la fonte è già uno zaino, scegli una borsa diversa per un trasporto utile.
return  RunScenario();
 object? RunScenario()
{
    UO.MassMove(500, 10, "0x0F7A", "backpack");
    UO.Print("Drag one matching item from the source chest");
    return null;
}

6. Seleziona un posto all'interno di una cassa in base a un oggetto già presente - classe dello scenario

Parametri e flusso di esecuzione:

  • Innanzitutto, posiziona manualmente l'oggetto nella posizione desiderata nel baule. Il primo AddObject seleziona il baule stesso e lo memorizza ID nel baule. Il secondo seleziona l'elemento al suo interno e memorizza ID in position_sample.
  • GetX/GetY per un elemento all'interno di un contenitore restituisce le sue coordinate all'interno di quel contenitore. Non dipendono da dove si trova la finestra del torace sullo schermo.
  • ritardo=350 ms, quantità=50 articoli interi, type=0 determinato dal futuro trasferimento manuale dalla fonte, destinazione=petto.
  • xey definiscono la posizione selezionata all'interno del baule, l'ultima z=0. L'oggetto position_sample serve solo per leggere le coordinate; l'origine e il tipo da migrare vengono determinati dalla successiva migrazione manuale.
  • Per uno zaino, sostituisci il petto con backpack o self. Per la terra, usa ground e coordinate della mappa come UO.GetX(), UO.GetY(), UO.GetZ() senza argomenti per la posizione attuale del personaggio.
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.Print("Select the destination chest");
        UO.AddObject("chest");
        UO.Print("Select an item already at the desired position inside that chest");
        UO.AddObject("position_sample");
        var x = UO.GetX("position_sample");
        var y = UO.GetY("position_sample");
        UO.MassMove(350, 50, 0, "chest", x, y, 0);
        UO.Print("Drag one source item to start the transfer");
        return null;
    }
}

7. Dal baule al suolo: seleziona un luogo con il mouse - scrittura diretta

Parametri e flusso di esecuzione:

  • ritardo=350 — almeno 350 ms tra richieste successive. quantità=50 - fino a 50 singoli articoli/intere pile, incluso un campione; queste non sono unità 50 dello stesso gruppo.
  • Dopo l'attivazione MassMove, raccogli l'oggetto dal baule aperto e posizionalo a terra con il mouse. Il suo tipo e la cassa originale sono determinati dal modello; Le destinazioni mondiali X/Y/Z vengono ricordate nella posizione di questo ripristino.
  • I restanti oggetti dello stesso tipo caricati da questo baule vengono inviati allo stesso punto a terra. Il contenuto dei sacchetti annidati e di altri tipi non viene influenzato. Per tutti gli elementi corrispondenti, sostituire 50 con 0.
  • MassMove non ha valore di ritorno. La procedura termina dopo l'attivazione della modalità, la coda continua a funzionare nel client. Il messaggio finale conta le richieste inviate, non le conferme del server. Per cancellare la coda rimanente, chiamare UO.MassMove().
UO.MassMove(350, 50);
UO.Print("Drag one item from the chest onto the ground");

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

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "massmove":

                    if (arguments.Length == 0) bridge.MassMove(-1, 0, 0, -1, -1, -1, 0);

                    else bridge.MassMove(NumberConversions.ToInt(arguments[0]),

                        arguments.Length > 1 ? NumberConversions.ToInt(arguments[1]) : 0,

                        arguments.Length > 2 ? ResolveType(arguments[2]) : 0,

                        arguments.Length > 3 ? ResolveTransferDestination(arguments[3], true) : -1,

                        arguments.Length > 4 ? NumberConversions.ToInt(arguments[4]) : -1,

                        arguments.Length > 5 ? NumberConversions.ToInt(arguments[5]) : -1,

                        arguments.Length > 6 ? NumberConversions.ToInt(arguments[6]) : 0);

                    break;

UO.MassMove(delay) — UO.MassMove(Any)

Parametri: delay (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "massmove":

                    if (arguments.Length == 0) bridge.MassMove(-1, 0, 0, -1, -1, -1, 0);

                    else bridge.MassMove(NumberConversions.ToInt(arguments[0]),

                        arguments.Length > 1 ? NumberConversions.ToInt(arguments[1]) : 0,

                        arguments.Length > 2 ? ResolveType(arguments[2]) : 0,

                        arguments.Length > 3 ? ResolveTransferDestination(arguments[3], true) : -1,

                        arguments.Length > 4 ? NumberConversions.ToInt(arguments[4]) : -1,

                        arguments.Length > 5 ? NumberConversions.ToInt(arguments[5]) : -1,

                        arguments.Length > 6 ? NumberConversions.ToInt(arguments[6]) : 0);

                    break;

UO.MassMove(delay, quantity) — UO.MassMove(Any,Any)

Parametri: delay (Any), quantity (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "massmove":

                    if (arguments.Length == 0) bridge.MassMove(-1, 0, 0, -1, -1, -1, 0);

                    else bridge.MassMove(NumberConversions.ToInt(arguments[0]),

                        arguments.Length > 1 ? NumberConversions.ToInt(arguments[1]) : 0,

                        arguments.Length > 2 ? ResolveType(arguments[2]) : 0,

                        arguments.Length > 3 ? ResolveTransferDestination(arguments[3], true) : -1,

                        arguments.Length > 4 ? NumberConversions.ToInt(arguments[4]) : -1,

                        arguments.Length > 5 ? NumberConversions.ToInt(arguments[5]) : -1,

                        arguments.Length > 6 ? NumberConversions.ToInt(arguments[6]) : 0);

                    break;

UO.MassMove(delay, quantity, type) — UO.MassMove(Any,Any,Any)

Parametri: delay (Any), quantity (Any), type (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "massmove":

                    if (arguments.Length == 0) bridge.MassMove(-1, 0, 0, -1, -1, -1, 0);

                    else bridge.MassMove(NumberConversions.ToInt(arguments[0]),

                        arguments.Length > 1 ? NumberConversions.ToInt(arguments[1]) : 0,

                        arguments.Length > 2 ? ResolveType(arguments[2]) : 0,

                        arguments.Length > 3 ? ResolveTransferDestination(arguments[3], true) : -1,

                        arguments.Length > 4 ? NumberConversions.ToInt(arguments[4]) : -1,

                        arguments.Length > 5 ? NumberConversions.ToInt(arguments[5]) : -1,

                        arguments.Length > 6 ? NumberConversions.ToInt(arguments[6]) : 0);

                    break;

UO.MassMove(delay, quantity, type, destination) — UO.MassMove(Any,Any,Any,Any)

Parametri: delay (Any), quantity (Any), type (Any), destination (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "massmove":

                    if (arguments.Length == 0) bridge.MassMove(-1, 0, 0, -1, -1, -1, 0);

                    else bridge.MassMove(NumberConversions.ToInt(arguments[0]),

                        arguments.Length > 1 ? NumberConversions.ToInt(arguments[1]) : 0,

                        arguments.Length > 2 ? ResolveType(arguments[2]) : 0,

                        arguments.Length > 3 ? ResolveTransferDestination(arguments[3], true) : -1,

                        arguments.Length > 4 ? NumberConversions.ToInt(arguments[4]) : -1,

                        arguments.Length > 5 ? NumberConversions.ToInt(arguments[5]) : -1,

                        arguments.Length > 6 ? NumberConversions.ToInt(arguments[6]) : 0);

                    break;

UO.MassMove(delay, quantity, type, destination, x, y, z) — UO.MassMove(Any,Any,Any,Any,Any,Any,Any)

Parametri: delay (Any), quantity (Any), type (Any), destination (Any), x (Any), y (Any), z (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "massmove":

                    if (arguments.Length == 0) bridge.MassMove(-1, 0, 0, -1, -1, -1, 0);

                    else bridge.MassMove(NumberConversions.ToInt(arguments[0]),

                        arguments.Length > 1 ? NumberConversions.ToInt(arguments[1]) : 0,

                        arguments.Length > 2 ? ResolveType(arguments[2]) : 0,

                        arguments.Length > 3 ? ResolveTransferDestination(arguments[3], true) : -1,

                        arguments.Length > 4 ? NumberConversions.ToInt(arguments[4]) : -1,

                        arguments.Length > 5 ? NumberConversions.ToInt(arguments[5]) : -1,

                        arguments.Length > 6 ? NumberConversions.ToInt(arguments[6]) : 0);

                    break;

ClassicUO — Bad Newbie & C# Scripts IDE

ClassicUO — Bad Newbie & C# Scripts IDE

Clone this wiki locally