Skip to content

IT UO Topic items Part 2

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

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

Oggetti — 2

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

Parti del riferimento

1 · 2

Riferimento completo dei comandi

UO.MoveItem

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

Firme C#

int UO.MoveItem(object? id);
int UO.MoveItem(object? id, object? amount);
int UO.MoveItem(object? id, object? amount, object? targetContainer);
int UO.MoveItem(object? item, object? amount, object? container, object? x);
int UO.MoveItem(object? item, object? amount, object? container, object? x, object? y);
int UO.MoveItem(object? id, object? amount, object? targetContainer, object? x, object? y, object? z);
int UO.MoveItem(object? item, object? amount, object? container, object? x, object? y, object? z, object? timeout);
int UO.MoveItem(object? item, object? amount, object? container, object? x, object? y, object? z, object? timeout, object? waitConfirmation);

Trasporta un oggetto/pila specifico tramite serial: catturato e lasciato cadere in un contenitore o a terra.

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.
  • item — 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. L'impostazione predefinita è 0.
  • targetContainer — 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.
  • container — 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 — Con un contenitore — X nel gump, predefinito 65535 (automatico). Quando sei a terra: mondo X, personaggio predefinito X.
  • y — Y nel gump o nel mondo Y; il valore predefinito è 65535 per il contenitore o il carattere Y per il terreno.
  • z — Altezza, per impostazione predefinita 0 in un contenitore o Z di un personaggio a terra.
  • timeout — Settimo argomento: attesa massima in ms, default 1000; un valore negativo è equivalente a 0. Utilizzato solo con l'ottavo waitConfirmation=true.
  • waitConfirmation — Ottavo argomento: true/1 include l'aspettativa di un cambiamento osservato nel mondo; false/0 (predefinito) restituisce il risultato dell'invio di una richiesta.

Valore restituito

int 1: il client ha accettato la richiesta di acquisizione e ripristino; 0—Non è stato possibile completare la richiesta. Quando waitConfirmation=true è inoltre necessario un cambiamento osservabile nel contenitore/coordinate o una diminuzione nello stack originale. Questo non è il serial del nuovo stack e non il numero di elementi trasferiti. Il server potrebbe rifiutarsi di funzionare.

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

Comportamento

  • Sono supportate tutte le lunghezze degli argomenti da 1 a 8. Dato x, è possibile omettere y/z: per essi vengono utilizzati i valori predefiniti descritti.
  • Il nome di destinazione noto viene risolto prima dell'acquisizione. Per terra, utilizzare ground/0 esplicitamente; un errore di battitura nel nome non dovrebbe gettare l'oggetto sul pavimento.
  • L'oggetto può trovarsi in un baule, in una borsa o in uno zaino: ground imposta la destinazione a terra, indipendentemente dal contenitore originale. Il primo argomento specifica il serial dell'oggetto stesso, non il baule o type. La squadra esegue il contrasto da sola; Non è necessario afferrare prima l'oggetto con il mouse.
  • Quando DropCheckCoord è acceso, lo scarico a terra oltre le due celle viene rifiutato. Il server controlla inoltre la disponibilità di spazio. X/Y sono celle della mappa, non pixel Gump; Z: altezza della superficie selezionata, incluso il negativo. Per un contenitore, X/Y indica ancora la posizione all'interno del suo gump.
  • In attesa di conferma utilizza lo stato del mondo del cliente: per una pila parziale - una diminuzione della quantità, per l'intero - un contenitore, per il terreno un altro X/Y/Z. All'interno del contenitore, la posizione esatta della gomma non è confermata da questa aspettativa; la scomparsa/l'unione di stack può complicare la verifica.
  • Questa non è una conferma di una transazione separata ID. Se l'oggetto era già nello stesso contenitore, la corrispondenza del contenitore non dimostra una nuova mossa all'interno del gump.

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

1. L'intero oggetto nello zaino è una sceneggiatura diretta

Parametri e flusso di esecuzione:

  • bottino - nome AddObject; manca l'importo ed è pari a 0, la destinazione è lo zaino.
  • Viene trasferito un elemento/pila, non tutti gli elementi di un determinato tipo.
var ok = UO.MoveItem("loot");
UO.Print("Move request: " + Convert.ToString(ok));

2. Parte dello stack in una posizione specifica del baule - funzione dello script

Parametri e flusso di esecuzione:

  • quantità=10 unità di una pila, chest è il nome del contenitore, x/y=60/70 all'interno del gump, z=0.
  • La quantità non ha il valore "dieci pile" adottato da MassMove.
return  RunScenario();
 object? RunScenario()
{
    var ok = UO.MoveItem("loot", 10, "chest", 60, 70, 0);
    return null;
}

3. La terra sotto il personaggio è una classe di scenario

Parametri e flusso di esecuzione:

  • ground seleziona esplicitamente il terreno; X/Y/Z mancanti sono presi dal carattere.
  • Per un altro punto, passa le sue coordinate mondiali, tenendo conto della distanza e di DropCheckCoord.
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.MoveItem("loot", 0, "ground");
        return null;
    }
}

4. Dal petto alla terra accanto al personaggio: sceneggiatura diretta

Parametri e flusso di esecuzione:

  • ground_item - salvato serial dell'oggetto selezionato in uno scrigno aperto. Il baule originale non viene passato come parametro separato. amount=0 prende l'intero stack; ad esempio, 10 richiederà fino a dieci unità di questo stack.
  • ground seleziona chiaramente il terreno. x/y — coordinate assolute della cella una cella lungo X dal carattere; z è preso dal carattere ed è adatto se la superficie adiacente è alla stessa altezza. Su una scala, un tavolo o un altro pavimento, impostare l'effettivo Z della superficie desiderata.
  • sent=1 significa inviare una richiesta da parte del client; senza l'ottavo parametro non è prevista la conferma del server. Il valore 0 significa che la richiesta non è riuscita. Questo è il flag numerico int 1/0: check sent != 0 oppure sent == 0; il confronto con bool non è valido.
  • Per resettarsi direttamente ai tuoi piedi è sufficiente UO.MoveItem('ground_item', 0, 'ground'): tutte e tre le coordinate verranno prese dal personaggio. Per posizionarlo all'interno di uno scrigno, invece di ground, specifica serial/il nome dello scrigno e le coordinate del suo gump.
UO.AddObject("ground_item");
var x = UO.GetX() + 1;
var y = UO.GetY();
var z = UO.GetZ();
var sent = UO.MoveItem("ground_item", 0, "ground", x, y, z);
if (Truth(sent == 1))
{
    UO.Print("Ground move request sent");
}
else
{
    UO.Print("Ground move request was not sent");
}

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

5. Richiedi conferma osservabile - Funzione script

Parametri e flusso di esecuzione:

  • timeout=1500 ms viene utilizzato perché waitConfirmation=true. x/y=-1 — posizionamento automatico.
  • 0 può indicare un timeout per una richiesta che è già stata inviata. Non ripetere il trasferimento alla cieca; Si prega di verificare prima le condizioni attuali dell'articolo.
return  RunScenario();
 object? RunScenario()
{
    var ok = UO.MoveItem("loot", 0, "backpack", -1, -1, 0, 1500, true);
    if (Truth(ok == 0))
    {
        UO.Print("Move was rejected or not confirmed");
    }

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

Parametri: id (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int MoveItem(InjectionValue id)

            => CompactMoveItem(new[] { id });

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

Parametri: id (Any), amount (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int MoveItem(InjectionValue id, InjectionValue amount)

            => CompactMoveItem(new[] { id, amount });

UO.MoveItem(id, amount, targetContainer) — UO.MoveItem(Any,Any,Any)

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

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int MoveItem(InjectionValue id, InjectionValue amount, InjectionValue targetContainer)

            => CompactMoveItem(new[] { id, amount, targetContainer });

UO.MoveItem(item, amount, container, x) — UO.MoveItem(Any,Any,Any,Any)

Parametri: item (Any), amount (Any), container (Any), x (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(CompactMoveItem(values))

UO.MoveItem(item, amount, container, x, y) — UO.MoveItem(Any,Any,Any,Any,Any)

Parametri: item (Any), amount (Any), container (Any), x (Any), y (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(CompactMoveItem(values))

UO.MoveItem(id, amount, targetContainer, x, y, z) — UO.MoveItem(Any,Any,Any,Any,Any,Any)

Parametri: id (Any), amount (Any), targetContainer (Any), x (Any), y (Any), z (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int MoveItem(InjectionValue id, InjectionValue amount, InjectionValue targetContainer, InjectionValue x, InjectionValue y, InjectionValue z)

            => CompactMoveItem(new[] { id, amount, targetContainer, x, y, z });

UO.MoveItem(item, amount, container, x, y, z, timeout) — UO.MoveItem(Any,Any,Any,Any,Any,Any,Any)

Parametri: item (Any), amount (Any), container (Any), x (Any), y (Any), z (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(CompactMoveItem(values))

UO.MoveItem(item, amount, container, x, y, z, timeout, waitConfirmation) — UO.MoveItem(Any,Any,Any,Any,Any,Any,Any,Any)

Parametri: item (Any), amount (Any), container (Any), x (Any), y (Any), z (Any), timeout (Any), waitConfirmation (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(CompactMoveItem(values))

UO.MoveItems

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

Firme C#

dynamic UO.MoveItems(object? container, object? itemsType, object? itemsColor, object? moveIntoID, object? x, object? y, object? z, object? delayMS);

Trasferisce tutti gli oggetti idonei direttamente da un contenitore all'altro o a terra. Gli elementi sono selezionati da graphic e hue; ogni stack viene trasferito interamente. Si tratta di trasportare oggetti, non di camminare con il personaggio o di attivare interattivamente MassMove.

Parametri

  • container — Numero seriale del contenitore di origine, ad esempio backpack, "backpack", nome AddObject o esadecimale-ID. Il contenuto deve essere già scaricato. 0 non è una fonte valida; ground non seleziona le cose intorno al personaggio. Per uno zaino, usa backpack anziché self.
  • itemsType - Elemento grafico, ad esempio 0x0EED - oro. Non le cose ID e non il corpo mobile. Numero negativo o 0xFFFF - tutti i tipi. La maschera array/tipo non è accettata.
  • itemsColor — Tonalità delle cose. -1 (o altro numero negativo) e 0xFFFF - qualsiasi; 0 - solo hue 0. Non serial e non notorietà.
  • moveIntoID — Seriale del contenitore di destinazione o alias dell'oggetto. Per il tuo zaino - backpack. Per la terra - il numero 0 (anche ground/"ground"/UO.Ground()). La fonte e la destinazione devono essere diverse. -1 non è l'abbreviazione di backpack in questo comando. Self - serial mobile invece di sostituire automaticamente il suo zaino.
  • x — Per un contenitore diverso da zero, la posizione ALL'INTERNO del suo gump; -1,-1 lascia il posizionamento al server. A terra - coordinate mondiali 0..65535, entrambe sono obbligatorie e non negative. Non i pixel dello schermo del mondo di gioco e non il punto finale del percorso.
  • y — Per un contenitore diverso da zero, la posizione ALL'INTERNO del suo gump; -1,-1 lascia il posizionamento al server. A terra - coordinate mondiali 0..65535, entrambe sono obbligatorie e non negative. Non i pixel dello schermo del mondo di gioco e non il punto finale del percorso.
  • z — Altezza del mondo quando steso a terra; utilizzare l'altitudine effettiva del sito (intervallo di protocollo -128..127). Nell'esempio del contenitore, indicare 0. Questo non è un indice del livello dell'attrezzatura.
  • delayMS - Ritardo tra le richieste accettate in millisecondi. In realtà, max(GrabDelay, max(0, DelayMS)); c'è anche un'attesa dopo l'ultimo trasferimento inviato. 350 non significa elementi 350 e non garantisce la conferma in 350 ms.

Valore restituito

Registrazione object? in realtà restituisce int 1/true se viene accettata almeno una richiesta di trasferimento, altrimenti 0/false. Questo non è un numero di elementi o una garanzia che TUTTE le corrispondenze verranno trasferite. Controlla il contenuto dopo che il server ha risposto. Una cancellazione di emergenza interrompe la procedura e non è necessario restituire false.

Comportamento

  • Sono richiesti tutti gli otto argomenti. Un elenco di figli diretti del contenitore originale viene creato una volta; Non esiste attraversamento ricorsivo. Una volta inclusa nell'elenco, la borsa viene spostata come un unico articolo insieme al suo contenuto, anziché essere disimballata.
  • Prende l'intero stack attuale di ogni partita. Il limite al numero di articoli o unità non viene impostato da questo comando; per tali scenari vedere UO.MassMove. Ignore non viene utilizzato come filtro aggiuntivo per questo campione.
  • Prima di ogni azione, ricontrolla che l'articolo sia ancora nel suo contenitore originale. Il divieto di annidare un contenitore in se stesso/discendente e l'indisponibilità dell'articolo potrebbero comportare un salto. Una coda non è una transazione: le azioni già inviate non vengono ripristinate.
  • Se source=0, sorgente/destinazione identica o terra con X/Y negativi, restituisce 0 e segnala un errore. Il server determina la risoluzione, la portata, la capacità e il risultato finale. Non eseguire contemporaneamente altre operazioni con gli oggetti sollevati.

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

1. Raccogli l'oro dal forziere selezionato in uno zaino - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • 0x0EED - type oro; - da 1 a ItemsColor - qualsiasi hue. -1,-1 dopo backpack è la posizione automatica nel gump, non a terra. 350 ms - il ritardo minimo desiderato, tenendo conto di GrabDelay. Tutte le pile d'oro diritte vengono prese intere.
var source = Asc(UO.GetSerial("lasttarget"), 0);
if (Truth(source == 0) || Truth(source == UO.Backpack()) || !(Truth(UO.Exists(source))))
{
    return null;
}
var sent = UO.MoveItems(source, 0x0EED, -1, "backpack", -1, -1, 0, 350);
if (Truth(Truth(sent) == false))
{
    UO.Print("No gold transfer request was accepted");
}

int Asc(object? value, int fallback = 0) { string text = Convert.ToString(value) ?? ""; if (text.StartsWith("0x", StringComparison.OrdinalIgnoreCase)) return int.TryParse(text[2..], System.Globalization.NumberStyles.HexNumber, System.Globalization.CultureInfo.InvariantCulture, out int hex) ? hex : fallback; return int.TryParse(text, out int number) ? number : fallback; }
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;

2. Posiziona le bende nella posizione specificata della gengiva toracica - funzione script

Parametri e flusso di esecuzione:

  • 0x0E21 - bende, non il corpo umano. backpack è la fonte, la destinazione è serial del baule. Tutte le partite sono dirette ad un punto 30,40; il server può unire gli stack o modificare la posizione.
return  RunScenario();
 object? RunScenario()
{
    var destination = Asc(UO.GetSerial("lasttarget"), 0);
    if (Truth(destination == 0) || Truth(destination == UO.Backpack()) || !(Truth(UO.Exists(destination))))
    {
        return null;
    }

    var sent = UO.MoveItems("backpack", 0x0E21, -1, destination, 30, 40, 0, 350);
    if (Truth(sent != 0))
    {
        UO.Print("Transfer requested; verify the destination contents");
    }

    return null;
}

int Asc(object? value, int fallback = 0)
{
    string text = Convert.ToString(value) ?? "";
    if (text.StartsWith("0x", StringComparison.OrdinalIgnoreCase))
        return int.TryParse(text[2..], System.Globalization.NumberStyles.HexNumber, System.Globalization.CultureInfo.InvariantCulture, out int hex) ? hex : fallback;
    return int.TryParse(text, out int number) ? number : fallback;
}

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

3. Posiziona tutte le pile diritte del type selezionato fianco a fianco sul terreno - classe dello scenario

Parametri e flusso di esecuzione:

  • itemType specifica la tipologia, non la quantità; tutte le sue pile diritte vengono trasportate in uno zaino. X+1/Y/Z è un esempio di punto adiacente alla stessa altezza: per una pendenza/muro selezionare la coordinata corretta. Per la modalità mondiale è richiesta l'assegnazione 0. true indica solo una richiesta accettata, non uno zaino liberato.
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(DropTypeBesideMe(0x0EED))))
        {
            UO.Print("No ground drop request was accepted");
        }

        return null;
    }

    dynamic DropTypeBesideMe(dynamic itemType)
    {
        if (!(Truth(UO.Connected())) || Truth(UO.Dead()))
        {
            return false;
        }

        var x = UO.GetX() + 1;
        var y = UO.GetY();
        var z = UO.GetZ();
        return UO.MoveItems("backpack", itemType, -1, 0, x, y, z, 350);
    }

    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.MoveItems(container, itemsType, itemsColor, moveIntoID, x, y, z, delayMS) — UO.MoveItems(Any,Any,Any,Any,Any,Any,Any,Any)

Parametri: container (Any), itemsType (Any), itemsColor (Any), moveIntoID (Any), x (Any), y (Any), z (Any), delayMS (Any)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "moveitems": return new InjectionValue(bridge.MoveItems(Arg(0), ResolveType(arguments[1]), Arg(2), Arg(3), Arg(4), Arg(5), Arg(6), Arg(7)));

UO.Name

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

Firme C#

string UO.Name();

Legge il nome del personaggio.

Parametri

Non ci sono parametri.

Valore restituito

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

Comportamento

  • I dati locali già ricevuti vengono letti. La richiesta non apre lo stato e non forza il server a inviare un aggiornamento. Dopo la morte, la transizione della mappa o l'eliminazione di un oggetto, i valori possono cambiare tra due chiamate.
  • C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

Script C# autonomi

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

Esempio semplice

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

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

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

1. Mostra testo dopo il login - script diretto

Parametri e flusso di esecuzione:

  • Non ci sono parametri: viene letto self.
  • La stringa vuota viene gestita in modo esplicito; questo non è il testo "0".
var text = UO.Name();
if (Truth(text != ""))
{
    UO.Print(text);
}
else
{
    UO.Print("Text is unavailable");
}

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

2. Aggiungi testo al messaggio di registro - funzione script

Parametri e flusso di esecuzione:

  • Il tuo carattere viene letto, il valore viene memorizzato come una linea.
  • L'operatore + unisce le stringhe; Convert.ToString non è necessario per questo risultato.
return  RunScenario();
 object? RunScenario()
{
    var text = UO.Name();
    UO.Print("Player имя: " + text);
    return null;
}

3. Confronta due istantanee: classe scenario

Parametri e flusso di esecuzione:

  • Entrambi i bandi si riferiscono a self; UO.Wait imposta la pausa 1000 ms.
  • La differenza potrebbe significare aggiornare i dati o lasciare il mondo. L'esempio non modifica il nome o il titolo.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

    async public Task<object?> RunScenarioAsync()
    {
        var previous = UO.Name();
        await Delay(1000);
        var current = UO.Name();
        if (Truth(previous != current))
        {
            UO.Print("Updated text: " + current);
        }

        return null;
    }

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

Implementazione del comando

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

UO.Name() — UO.Name()

Parametri: Nessun parametro.

Risultato: string / String.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

() => bridge.GetName(bridge.Self)

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

UO.Picking

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

Firme C#

int UO.Picking();

Controlla se il cursore del client è occupato da un oggetto prelevato.

Parametri

Non ci sono parametri.

Valore restituito

int 1 - ItemHold.Set abilitato; 0 - non installato. Questo è uno stato del client, non ID o una conferma di consegna del server. Viene preso in considerazione un oggetto raccolto con il mouse o con un altro script.

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

Comportamento

  • La lettura non solleva né lascia cadere un oggetto.
  • Per il tuo trasferimento, controlla anche il risultato di Drag/DragItem; il cursore occupato di qualcun altro non significa che l'oggetto desiderato è stato preso con successo.

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

1. Mostra stato - script diretto

Parametri e flusso di esecuzione:

  • Non ci sono argomenti.
  • Viene visualizzato 1 o 0.
UO.Print(Convert.ToString(UO.Picking()));

2. Controllare le mani occupate prima della presa - funzione 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  RunScenario();
 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;

3. Attendi il cursore libero con limite - classe script

Parametri e flusso di esecuzione:

  • Il controllo viene ripetuto fino a venti volte con pause di 50 ms.
  • Il comando non rilascia il cursore né annulla la mossa di qualcun altro.
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 tries = 0;
        while (Truth(UO.Picking()) && Truth(tries < 20))
        {
            await Delay(50);
            tries = tries + 1;
        }

        if (Truth(UO.Picking()))
        {
            UO.Print("Cursor is still occupied");
        }

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

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

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

UO.ReceiveObjectName

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

Firme C#

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

Richiede il nome di un oggetto con una richiesta con un solo clic.

Parametri

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

Valore restituito

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

Comportamento

  • Bridge.ReceiveObjectName chiama Click(id), quindi attende fino a quando max(0,timeout) finché GetName(id) è vuoto; pausa non superiore a 25 ms. Un nome già noto mette subito fine all'attesa.
  • Senza timeout, viene eseguito solo Click. Non esiste un nome di ritorno: leggi GetName separatamente; la fine dell'attesa può significare timeout.

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Richiede il nome di un oggetto con una richiesta con un solo clic.
UO.ReceiveObjectName("lasttarget");

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • Bridge.ReceiveObjectName chiama Click(id), quindi attende fino a quando max(0,timeout) finché GetName(id) è vuoto; pausa non superiore a 25 ms. Un nome già noto mette subito fine all'attesa.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Exists("lasttarget")))
    {
        UO.ReceiveObjectName("lasttarget", 1000);
    }

    return null;
}

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

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

  • Senza timeout, viene eseguito solo Click. Non esiste un nome di ritorno: leggi GetName separatamente; la fine dell'attesa può significare timeout.
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.ReceiveObjectName(id, 1000);
            UO.Print(UO.GetName(id));
        }

        return null;
    }

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

Implementazione del comando

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

UO.ReceiveObjectName(id) — UO.ReceiveObjectName(Any)

Parametri: id (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

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

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

Parametri: id (Any), timeout (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

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

UO.TicksUse

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

Firme C#

int UO.TicksUse();

Legge il contrassegno salvato TicksUse.

Parametri

Non ci sono parametri.

Valore restituito

int: indica UO.Timer in decimi di secondo dall'inizio del runtime. 0 - la boa non è stata ancora posizionata oppure l'evento è avvenuto nel primo decimo di secondo; non sono i millisecondi o l'ora del calendario.

Comportamento

  • Restituisce il campo ticksUse. Viene aggiornato da UseObject; non si tratta di un'osservazione automatica di tutte le attività manuali/server. Il comando in sé non modifica il segno.
  • UO.Timer() - il voto calcola l'età in decimi di secondo. I voti non vengono confrontati tra tempi di esecuzione 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.

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Legge il contrassegno salvato TicksUse.
var stamp = UO.TicksUse();
UO.Print(stamp);

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • Restituisce il campo ticksUse. Viene aggiornato da UseObject; non si tratta di un'osservazione automatica di tutte le attività manuali/server. Il comando in sé non modifica il segno.
return  RunScenario();
 object? RunScenario()
{
    var stamp = UO.TicksUse();
    var ageTenths = UO.Timer() - stamp;
    UO.Print(ageTenths);
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

  • UO.Timer() - il voto calcola l'età in decimi di secondo. I voti non vengono confrontati tra tempi di esecuzione 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.TicksUse();
        UO.Wait(250);
        var after = UO.TicksUse();
        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.TicksUse() — UO.TicksUse()

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int TicksUse() => ticksUse;

UO.UpdateObject

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

Firme C#

void UO.UpdateObject(object? id);

Richiede un aggiornamento a un oggetto già caricato.

Parametri

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

Valore restituito

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

Comportamento

  • Per Mobile, viene chiamato RequestMobileStatus(..., true), per Articolo - SingleClick. Se serial non è presente in entrambe le tabelle locali, non vi è alcuna azione. Questo non sta scaricando un oggetto sconosciuto o confermando un aggiornamento.
  • Bridge invia la richiesta sullo streaming del gioco. Si applicano le regole del server; Non è prevista l'attesa di conferma.

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Richiede un aggiornamento a un oggetto già caricato.
var id = UO.GetSerial("lasttarget");
if (Truth(UO.Exists(id)))
{
    UO.UpdateObject(id);
}

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

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • Per Mobile, viene chiamato RequestMobileStatus(..., true), per Articolo - SingleClick. Se serial non è presente in entrambe le tabelle locali, non vi è alcuna azione. Questo non sta scaricando un oggetto sconosciuto o confermando un aggiornamento.
return  RunScenario();
 object? RunScenario()
{
    var id = UO.GetSerial("self");
    if (Truth(UO.Exists(id)))
    {
        UO.UpdateObject(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:

  • Bridge invia la richiesta sullo streaming del gioco. Si applicano le regole del server; Non è prevista l'attesa di conferma.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        ApplyToLoaded(UO.GetSerial("lasttarget"));
        return null;
    }

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

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

Parametri: id (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public void UpdateObject(InjectionValue id) => bridge.UpdateObject(GetObject(id));

UO.UseFromGround

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

Firme C#

int UO.UseFromGround(object? @type);
int UO.UseFromGround(object? @type, object? color);

Cerca un oggetto del graphic dato sul terreno/nel mondo e richiama immediatamente la sua applicazione. Solitamente utilizzato per oggetti vicini, come l'apertura di uno zaino. Una caratteristica importante di questo runtime: la ricerca è basata su FindType e può trovare anche mobile con lo stesso body; Questa non è strettamente una selezione di soli articoli. Per gli elementi con un raggio esplicito e una selezione più vicina, utilizzare UseType(..., ground, ...).

Parametri

  • type - Obbligatorio graphic. Ad esempio, 0x0E75 è uno zaino. Numero o stringa esadecimale numerica; numero negativo/0xFFFF — qualsiasi graphic. Valori corporei come 0x0190 (maschio) e 0x0191 (femmina) possono selezionare mobile; non sostituirli con l'elemento type. Con questo modulo non vengono trasmessi due tipi contemporaneamente.
  • color - Opzionale hue, predefinito - 1 (qualsiasi). Numero negativo/0xFFFF - qualsiasi, 0 - solo hue 0. Non ci sono altri parametri: contenitore, distanza, più vicino e maxZ non vengono aggiunti a questo comando.

Valore restituito

int - serial del primo oggetto trovato, passato a UseObject, o 0. Questo non è il numero di oggetti, non graphic e non true/false. L'oggetto potrebbe essere trovato, ma il server potrebbe non consentirne l'utilizzo. Controlla l'id != 0 e l'effetto di gioco previsto separatamente.

Comportamento

  • Utilizza la corrente FindDistance e FindVertical, tiene conto di Ignore. Il contenitore di ricerca è fisso come ground, il contenuto nidificato non viene attraversato. I cellulari escludono self; non esiste alcuna restrizione separata su vita/visibilità/notorietà.
  • Aggiorna FindItem/FindCount/GetFoundItems con tutte le corrispondenze della ricerca, ma applica solo il primo risultato. Non è garantito quello più vicino; gli oggetti del mondo vengono controllati prima dei cellulari.
  • Non raccoglie un oggetto nello zaino, non muove il personaggio, non attende la risposta del server o la fine del bersaglio. Se non c'è corrispondenza, stampa un messaggio. Per effettuare la ricerca senza un'azione, utilizzare UO.FindType.

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

1. Apri uno zaino sdraiato di tipo standard - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • solo type; qualsiasi hue. Vengono utilizzati gli attuali FindDistance/FindVertical. bag - ID del primo risultato, non necessariamente quello più vicino. Il contenuto si aprirà solo se il server lo consente.
var bag = UO.UseFromGround(0x0E75);
if (Truth(bag != 0))
{
    UO.AddObject("ground_bag", bag);
}
else
{
    UO.Print("No loaded ground backpack matches the search settings");
}

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

2. Applicare uno zaino del colore desiderato vicino alla stessa altezza - funzione script

Parametri e flusso di esecuzione:

  • La ricerca è limitata a due celle e lo stesso Z. Il colore 0x0044 è dato a titolo di esempio: sostituiscilo con hue del tuo articolo. Le impostazioni vengono ripristinate anche in caso di errore.
return  RunScenario();
 object? RunScenario()
{
    var oldDistance = UO.FindDistance();
    var oldZ = UO.FindVertical();
    try
    {
        UO.FindDistance(2);
        UO.FindVertical(0);
        var bag = UO.UseFromGround(0x0E75, 0x0044);
        if (Truth(bag != 0))
        {
            UO.AddObject("colored_ground_bag", bag);
        }
    }
    finally
    {
        UO.FindDistance(oldDistance);
        UO.FindVertical(oldZ);
    }

    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 completa con raggio di ricerca esplicito - Classe di script

Parametri e flusso di esecuzione:

  • raggio specifica FindDistance anziché il terzo argomento UseFromGround. 3000 ms — tempo di visualizzazione dell'esempio, non di conferma dell'apertura; tipo di finestra 3 - contenitore. I risultati di questa ricerca rimangono in Trova*.
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 selected = OpenGroundBagWithin(2);
        if (Truth(selected != 0))
        {
            await Delay(3000);
            UO.CloseClientUIWindow(3, selected);
        }

        return null;
    }

    dynamic OpenGroundBagWithin(dynamic radius)
    {
        var previous = UO.FindDistance();
        try
        {
            UO.FindDistance(radius);
            return UO.UseFromGround(0x0E75, -1);
        }
        finally
        {
            UO.FindDistance(previous);
        }
    }

    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.UseFromGround(type) — UO.UseFromGround(Any)

Parametri: type (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int UseFromGround(InjectionValue type) => UseFromGround(type, new InjectionValue(-1));

UO.UseFromGround(type, color) — UO.UseFromGround(Any,Any)

Parametri: type (Any), color (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int UseFromGround(InjectionValue type, InjectionValue color)

        {

            int id = bridge.FindType(ResolveType(type), NumberConversions.ToInt(color), 1, -1, false);

            if (id != 0)

                UseObject(id);

            else

                SystemMessage("No matching item found on ground.");

            return id;

        }

UO.UseItemOnMobile

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

Firme C#

void UO.UseItemOnMobile(object? itemSerial, object? targetSerial);

Prepara il bersaglio del personaggio e usa l'oggetto.

Parametri

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

Valore restituito

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

Comportamento

  • ExecuteClientApiCompatibility chiama prima il bridge.WaitTargetObject(TargetSerial), poi il bridge.UseObject(ItemSerial). Gli argomenti non vengono scambiati. Queste chiamate bridge dirette non aggiornano il runtime TicksTarget/TicksUse.
  • Non controlla il tipo di destinazione/elemento e non attende il cursore. Preparare il bersaglio prima dell'uso impedisce di perdere un bersaglio che arriva rapidamente, ma il server determina comunque se l'azione è valida.

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.UseItemOnMobile");
UO.UseItemOnMobile("0x40001234", "self");

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Prepara il bersaglio del personaggio e usa l'oggetto.
UO.UseItemOnMobile("0x40001234", "self");

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • ExecuteClientApiCompatibility chiama prima il bridge.WaitTargetObject(TargetSerial), poi il bridge.UseObject(ItemSerial). Gli argomenti non vengono scambiati. Queste chiamate bridge dirette non aggiornano il runtime TicksTarget/TicksUse.
return  RunScenario();
 object? RunScenario()
{
    var item = UO.GetSerial("lastobject");
    var mobile = UO.GetSerial("lasttarget");
    if (Truth(UO.Exists(item)) && Truth(UO.Exists(mobile)))
    {
        UO.UseItemOnMobile(item, mobile);
    }

    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:

  • Non controlla il tipo di destinazione/elemento e non attende il cursore. Preparare il bersaglio prima dell'uso impedisce di perdere un bersaglio che arriva rapidamente, ma il server determina comunque se l'azione è valida.
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.GetSerial("lastobject");
        if (Truth(UO.Exists(item)))
        {
            UO.UseItemOnMobile(item, "self");
            UO.Print(UO.Waiting());
        }

        return null;
    }

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

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.UseItemOnMobile(itemSerial, targetSerial) — UO.UseItemOnMobile(Any,Any)

Parametri: itemSerial (Any), targetSerial (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "useitemonmobile": bridge.WaitTargetObject(Arg(1)); bridge.UseObject(Arg(0)); return InjectionValue.Unit;

UO.UseObject

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

Firme C#

void UO.UseObject(object? objID);

Richiede l'utilizzo di un oggetto da serial. Chiamate del bridge GameActions.DoubleClick; L'elemento non è stato cercato type.

Parametri

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

Valore restituito

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

Comportamento

  • GetObject consente l'alias; il nome sconosciuto dà -1. Dopo la chiamata, il runtime aggiorna TicksUse con il valore di UO.Timer; Questo è il momento della richiesta, non della conferma da parte del server.
  • Bridge invia la richiesta sullo streaming del gioco. Si applicano le regole del server; Non è prevista l'attesa di conferma.

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Richiede l'utilizzo di un oggetto da serial. Chiamate del bridge GameActions.DoubleClick; L'elemento non è stato cercato type.
var id = UO.GetSerial("lasttarget");
if (Truth(UO.Exists(id)))
{
    UO.UseObject(id);
}

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

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • GetObject consente l'alias; il nome sconosciuto dà -1. Dopo la chiamata, il runtime aggiorna TicksUse con il valore di UO.Timer; Questo è il momento della richiesta, non della conferma da parte del server.
return  RunScenario();
 object? RunScenario()
{
    var id = UO.GetSerial("self");
    if (Truth(UO.Exists(id)))
    {
        UO.UseObject(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:

  • Bridge invia la richiesta sullo streaming del gioco. Si applicano le regole del server; Non è prevista l'attesa di conferma.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        ApplyToLoaded(UO.GetSerial("lasttarget"));
        return null;
    }

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

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

Parametri: objID (Any/Integer/String)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

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

UO.UseObject(objID) — UO.UseObject(Integer)

Parametri: objID (Any/Integer/String)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public void UseObject(int id)

        {

            bridge.UseObject(id);

            ticksUse = Timer();

        }

UO.UseObject(objID) — UO.UseObject(String)

Parametri: objID (Any/Integer/String)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public void UseObject(string id) => UseObject(GetObject(id));

UO.UseType

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

Firme C#

int UO.UseType(object? @type);
int UO.UseType(object? @type, object? color);
int UO.UseType(object? @type, object? color, object? container);
int UO.UseType(object? @type, object? color, object? container, object? distance);
int UO.UseType(object? @type, object? color, object? container, object? distance, object? nearest);
int UO.UseType(object? @type, object? color, object? container, object? distance, object? nearest, object? maxZ);

Trova un elemento del graphic/type desiderato e lo applica. Ad esempio, bevi una pozione da uno zaino, apri uno zaino vicino o usa un oggetto da un contenitore selezionato. Questo comando non cerca né sposta il personaggio. Se un elemento richiede un ambito, l'obiettivo deve essere preparato separatamente.

Parametri

  • type — Grafica dell'articolo: numero o stringa esadecimale; ad esempio, 0x0F0C è un tipo di pozione curativa, 0x0E75 è uno zaino. Questo non è un carattere serial o body. Un numero negativo o 0xFFFF consente qualsiasi type; per un'azione significativa, è meglio graphic accurato.
  • color — Tonalità dell'elemento, predefinita - 1 (qualsiasi). Qualsiasi numero negativo o 0xFFFF rimuove il filtro; 0 sceglie l'oggetto non verniciato. Non la notorietà e non il colore del testo.
  • container — Predefinito -1: il tuo zaino e i sottocontainer caricati. "my" significa la stessa cosa. "backpack" o l'esplicito serial del contenitore specifica la radice dell'attraversamento ricorsivo. ground/"ground"/UO.Ground(), i numerici 0/1 denotano solo oggetti del mondo. Self non è sinonimo di backpack; utilizzare uno zaino esplicito. Un alias di oggetto sconosciuto/nullo può essere risolto come uno zaino: prima controlla il contenitore trasferito usando Exists.
  • distance — Intervallo geometrico massimo X/Y, non la lunghezza del percorso. L'argomento predefinito o negativo è FindDistance. 0 significa la stessa cella. Per gli oggetti in un contenitore, il cliente tiene conto della distanza dal proprietario.
  • nearest — Predefinito true: seleziona la cosa più vicina, se uguale, quella più piccola serial. false: trovato per primo nell'attraversamento senza ordinamento. Non il numero di articoli o la modalità di esecuzione.
  • maxZ — Massima differenza assoluta tra l'altezza del mondo Z e il personaggio. L'argomento predefinito o negativo è FindVertical. 0 richiede la stessa Z. Per l'oggetto nella borsa viene utilizzata l'altezza del contenitore esterno a terra o il carattere del proprietario; le coordinate Gump interne non sono considerate coordinate mondiali. Questo è un filtro di altezza, non un controllo della pedonabilità o della linea di vista.

Valore restituito

int - serial dell'articolo per il quale viene chiamato UseObject; 0 se non ci sono corrispondenze. Anche la registrazione con ReturnKind object? in realtà restituisce un numero. Questo non è true/false o conferma d'uso da parte del server: controlla used != 0 anziché used == true. Affinché l'effetto abbia esito positivo, è necessario un controllo separato dello stato, del contenuto o del registro.

Comportamento

  • Da 1 a 6 argomenti. Per impostare l'intervallo, specificare anche colore e contenitore. Per specificare maxZ, completare tutte e sei le posizioni. Array type, maschera tramite | e obiettivi aggiuntivi non sono accettati da questo comando.
  • Le forme regolari con int/string e le forme estese utilizzano CompactUseType: solo elementi, Ignore, distanza e altezza; i contenitori vengono attraversati in modo ricorsivo sul contenuto già caricato. Il contenitore di caricamento non si apre automaticamente. FindItem/FindCount/GetFoundItems non vengono aggiornati da questo ramo.
  • L'altezza dei proprietari e dei contenitori condivisi viene calcolata una volta per chiamata per evitare di ripetere l'attraversamento per ogni stack. Una catena di contenitori circolare o eccessivamente profonda (collegamenti 128 senza radice trovata) non viene utilizzata come corrispondenza di altezza.
  • Mantiene una registrazione compatibile comune di due object?: instrada una chiamata al bridge.UseType utilizzando FindType sullo zaino, aggiornando Trova* e selezionando il primo risultato. Per una forma compatta prevedibile, utilizzare int/string anziché conversioni implicite di tipi di valore inappropriati.
  • UseObject invia un'azione di lancio, ma il comando non attende il bersaglio, la guarigione, il bere, l'apertura di una finestra o il guasto del server. L'intervallo di ricerca non estende l'intervallo di utilizzo consentito dal server.
  • Se non c'è corrispondenza, il modulo compatto stampa il messaggio e restituisce 0. Se non è presente alcun carattere/collegamento, il risultato non deve essere considerato permesso di agire. Per ID preciso utilizzare UO.UseObject.

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

1. Applica una pozione curativa da uno zaino - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • 0x0F0C è un esempio di un tipo standard di pozione curativa. Il server può rifiutare l'azione a causa delle condizioni del carattere, della latenza o delle proprie regole. Colore e gamma non sono specificati separatamente: si applicano le impostazioni predefinite.
if (!(Truth(UO.Connected())) || Truth(UO.Dead()))
{
    return null;
}
var used = UO.UseType(0x0F0C);
if (Truth(used == 0))
{
    UO.Print("No matching healing potion in the loaded backpack");
}
else
{
    UO.Print("Potion use requested; check health and the game message");
}

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

2. Apri lo zaino più vicino a terra entro due celle - funzione script

Parametri e flusso di esecuzione:

  • 0x0E75 — type di uno zaino, -1 — qualsiasi hue, ground — oggetti del mondo. 2 - celle X/Y, true - più vicine, 4 - differenza Z. Restituzione bagaglio — ID. L'accesso ai contenuti è determinato dal server; la squadra non ritira lo zaino.
return  RunScenario();
 object? RunScenario()
{
    var bag = UO.UseType(0x0E75, -1, "ground", 2, true, 4);
    if (Truth(bag != 0))
    {
        UO.AddObject("nearby_bag", bag);
    }
    else
    {
        UO.Print("No suitable ground backpack within the selected bounds");
    }

    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. Utilizza un oggetto da un contenitore preselezionato - classe di scenario

Parametri e flusso di esecuzione:

  • itemType — graphic cose, fonte — contenitore serial separato. L'aiutante restituisce serial/0 come UseType. Anche un oggetto trovato può essere impedito dal server di essere utilizzato da qualcun altro o da un contenitore remoto.
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 source = Asc(UO.GetSerial("lasttarget"), 0);
        if (Truth(source == 0) || !(Truth(UO.Exists(source))))
        {
            return null;
        }

        UO.AddObject("supply", source);
        var used = UseFromNamedSupply(0x0F0C);
        if (Truth(used == 0))
        {
            UO.Print("Supply item was not found with these filters");
        }

        return null;
    }

    dynamic UseFromNamedSupply(dynamic itemType)
    {
        var source = Asc(UO.GetSerial("supply"), 0);
        if (Truth(source == 0) || !(Truth(UO.Exists(source))))
        {
            return 0;
        }

        return UO.UseType(itemType, 0, source, 2, false, 16);
    }

    int Asc(object? value, int fallback = 0)
    {
        string text = Convert.ToString(value) ?? "";
        if (text.StartsWith("0x", StringComparison.OrdinalIgnoreCase))
            return int.TryParse(text[2..], System.Globalization.NumberStyles.HexNumber, System.Globalization.CultureInfo.InvariantCulture, out int hex) ? hex : fallback;
        return int.TryParse(text, out int number) ? number : fallback;
    }

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

Implementazione del comando

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

UO.UseType(type) — UO.UseType(Integer)

Parametri: type (Integer/String)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int UseType(int type) => UseType(type, -1);

UO.UseType(type) — UO.UseType(String)

Parametri: type (Integer/String)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int UseType(string type) => UseType(ResolveType(type));

UO.UseType(type, color) — UO.UseType(Any,Any)

Parametri: type (Any/Integer/String), color (Any/Integer/String)

Risultato: int / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "usetype": return new InjectionValue(bridge.UseType(ResolveType(arguments[0]), arguments.Length > 1 ? Arg(1) : -1));

UO.UseType(type, color) — UO.UseType(Integer,Integer)

Parametri: type (Any/Integer/String), color (Any/Integer/String)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int UseType(int type, int color) => CompactUseType(new[]

        {

            new InjectionValue(type),

            new InjectionValue(color)

        });

UO.UseType(type, color) — UO.UseType(Integer,String)

Parametri: type (Any/Integer/String), color (Any/Integer/String)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int UseType(int type, string color) => UseType(type, NumberConversions.ToInt(color));

UO.UseType(type, color) — UO.UseType(String,Integer)

Parametri: type (Any/Integer/String), color (Any/Integer/String)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int UseType(string type, int color) => UseType(ResolveType(type), color);

UO.UseType(type, color) — UO.UseType(String,String)

Parametri: type (Any/Integer/String), color (Any/Integer/String)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int UseType(string type, string color) => UseType(ResolveType(type), NumberConversions.ToInt(color));

UO.UseType(type, color, container) — UO.UseType(Any,Any,Any)

Parametri: type (Any), color (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(CompactUseType(values))

UO.UseType(type, color, container, distance) — UO.UseType(Any,Any,Any,Any)

Parametri: type (Any), color (Any), container (Any), distance (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(CompactUseType(values))

UO.UseType(type, color, container, distance, nearest) — UO.UseType(Any,Any,Any,Any,Any)

Parametri: type (Any), color (Any), container (Any), distance (Any), nearest (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(CompactUseType(values))

UO.UseType(type, color, container, distance, nearest, maxZ) — UO.UseType(Any,Any,Any,Any,Any,Any)

Parametri: type (Any), color (Any), container (Any), distance (Any), nearest (Any), maxZ (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(CompactUseType(values))

UO.UseWorldObject

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

Firme C#

void UO.UseWorldObject(object? serialOrName);

Abilita da serialOrName a GetObject e chiama UseObject. Il nome della stringa è un alias dell'oggetto, non il nome graphic/type.

Parametri

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

Valore restituito

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

Comportamento

  • Registrato nei metadati direttamente su UserObject. Questo è un uso normale di serial, non una ricerca a livello di server.
  • Bridge invia la richiesta sullo streaming del gioco. Si applicano le regole del server; Non è prevista l'attesa di conferma.

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Abilita da serialOrName a GetObject e chiama UseObject. Il nome della stringa è un alias dell'oggetto, non il nome graphic/type.
var id = UO.GetSerial("lasttarget");
if (Truth(UO.Exists(id)))
{
    UO.UseWorldObject(id);
}

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

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • Registrato nei metadati direttamente su UserObject. Questo è un uso normale di serial, non una ricerca a livello di server.
return  RunScenario();
 object? RunScenario()
{
    var id = UO.GetSerial("self");
    if (Truth(UO.Exists(id)))
    {
        UO.UseWorldObject(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:

  • Bridge invia la richiesta sullo streaming del gioco. Si applicano le regole del server; Non è prevista l'attesa di conferma.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        ApplyToLoaded(UO.GetSerial("lasttarget"));
        return null;
    }

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

    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.UseWorldObject(serialOrName) — UO.UseWorldObject(Any)

Parametri: serialOrName (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public void UserObject(InjectionValue serialOrName)

            => UseObject(GetObject(serialOrName));

UO.UserObject

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

Firme C#

void UO.UserObject(object? serialOrName);

Abilita da serialOrName a GetObject e chiama UseObject. Il nome della stringa è un alias dell'oggetto, non il nome graphic/type.

Parametri

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

Valore restituito

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

Comportamento

  • Stesso percorso di utilizzo di UO.UseWorldObject. Il comando non crea un oggetto personalizzato né aggiunge il nome AddObject.
  • Bridge invia la richiesta sullo streaming del gioco. Si applicano le regole del server; Non è prevista l'attesa di conferma.

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Abilita da serialOrName a GetObject e chiama UseObject. Il nome della stringa è un alias dell'oggetto, non il nome graphic/type.
var id = UO.GetSerial("lasttarget");
if (Truth(UO.Exists(id)))
{
    UO.UserObject(id);
}

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

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • Stesso percorso di utilizzo di UO.UseWorldObject. Il comando non crea un oggetto personalizzato né aggiunge il nome AddObject.
return  RunScenario();
 object? RunScenario()
{
    var id = UO.GetSerial("self");
    if (Truth(UO.Exists(id)))
    {
        UO.UserObject(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:

  • Bridge invia la richiesta sullo streaming del gioco. Si applicano le regole del server; Non è prevista l'attesa di conferma.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        ApplyToLoaded(UO.GetSerial("lasttarget"));
        return null;
    }

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

    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.UserObject(serialOrName) — UO.UserObject(Any)

Parametri: serialOrName (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public void UserObject(InjectionValue serialOrName)

            => UseObject(GetObject(serialOrName));

ClassicUO — Bad Newbie & C# Scripts IDE

ClassicUO — Bad Newbie & C# Scripts IDE

Clone this wiki locally