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

Ricerca — 2

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

Parti del riferimento

1 · 2

Riferimento completo dei comandi

UO.FindMan

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

Firme C#

void UO.FindMan();
dynamic UO.FindMan(object? notoriety);
dynamic UO.FindMan(object? notoriety, object? distance);
dynamic UO.FindMan(object? notoriety, object? distance, object? nearest);
dynamic UO.FindMan(object? notoriety, object? distance, object? nearest, object? maxZ);
dynamic UO.FindMan(object? notoriety, object? distance, object? nearest, object? maxZ, object? body);
dynamic UO.FindMan(object? notoriety, object? distance, object? nearest, object? maxZ, object? body, object? color);
dynamic UO.FindMan(object? notoriety, object? distance, object? nearest, object? maxZ, object? body, object? color, object? includeSelf);

Trova uno serial per notorietà, distanza, altezza, corpo e hue. Utilizzato per preselezionare un bersaglio senza attacco automatico.

Parametri

notoriety — Relationship status to the character received from the server: 0 — unknown, 1 — Innocent, 2 — Ally, 3 — Gray, 4 — Criminal, 5 — Enemy, 6 — Murderer, 7 - Invulnerabile. Il numero indica uno stato; "5|6" o un array di numeri - uno qualsiasi dei precedenti. Non è il colore dei vestiti o la classe. Un numero negativo (solitamente -1), 0xFFFF, "qualsiasi", una stringa vuota o un array vuoto disabilitano separatamente questo filtro. Una stringa non valida senza numeri validi non trova nessuno. L'ordine degli stati non stabilisce la priorità. Il filtro 5 seleziona il nemico invece di selezionare automaticamente qualsiasi NPC/mostro; i valori effettivi dipendono dal server.
distance — Raggio orizzontale nelle celle compreso: 5 consente la distanza 0..5. La distanza è max(abs(dx),abs(dy)), quindi anche la diagonale adiacente è 1. Per impostazione predefinita o se il numero è negativo, viene utilizzato UO.FindDistance() anziché la ricerca illimitata. 0 lascia la stessa cella X/Y. Non la lunghezza del percorso; gli ostacoli e i pavimenti non vengono controllati da questo parametro.
nearest - true/1 per impostazione predefinita - il più vicino, a parità di distanza il più piccolo serial; false/0 - il primo nell'elenco dei clienti, non il più lontano.
maxZ — Massimi addominali (Z del bersaglio - Z del proprio personaggio), inclusi, in unità Z del mondo. Questo non è il numero di piani o di celle X/Y. maxZ=4 con il giocatore Z 10 consente il bersaglio Z 6..14; 0 richiede esattamente la stessa altezza. Per impostazione predefinita/per un numero negativo, viene preso UO.FindVertical(). Sulle scale, una Z uguale può eliminare il bersaglio desiderato. Anche una piccola differenza in Z non dimostra l'accessibilità del pavimento.
body - Grafica del corpo del personaggio/NPC, non ID di un personaggio specifico e non type dell'armatura indossata. Un numero, una stringa esadecimale, la stringa "0x0190|0x0191" o un array di numeri. 0x0190 (400) - maschio umano; 0x0191 (401) - donna umana. La maschera unisce entrambi i corpi. L'elenco non include automaticamente altre razze, fantasmi o trasformazioni; tabella dei tipi di corpo grafico standard. Un numero negativo (-1 per impostazione predefinita), 0xFFFF, "qualsiasi", una stringa vuota o un solo array vuoto - qualsiasi corpo. Il testo sconosciuto senza un numero valido produce un risultato vuoto.
color — Tonalità di mobile stesso: int o stringa numerica/esadecimale. Numero negativo (-1 per impostazione predefinita) e 0xFFFF - qualsiasi hue; 0 è esattamente hue 0 e non un valore qualsiasi. Non il colore della striscia della notorietà o la tonalità dei vestiti. Questo parametro non controlla il colore del capo indossato.
includeSelf - true/1 consente self soggetto ad altri filtri; false/0 esclude per impostazione predefinita. Ignore si applica anche a self.

Valore restituito

int serial, o 0 senza risultato. Controlla l'ID!= 0; non è bool e non è una quantità. Non cambia FindItem/FindCount/GetFoundItems e non avvia un attacco.

Comportamento

Ricerca locale: solo cellulari già scaricati. Ignore viene preso in considerazione; self è escluso, ad eccezione dell'esplicito includeSelf=true nei comandi che lo supportano. I contenitori e gli oggetti non sono mobili.
Le condizioni si applicano insieme (AND). Le alternative valide all'interno di body/notorietà sono combinate tramite OR. La ricerca non cambia FindItem, FindCount e GetFoundItems.
In body/notorietà, la maschera con numeri validi utilizza questi: "any|5" la limita ancora a 5. Gli elementi vuoti/non validi accanto ai numeri validi vengono ignorati. Per nessuna restrizione, passa -1 separatamente. Non portare questa regola a classMask: il nome della classe sconosciuta rifiuta l'intero elenco.
Le squadre non aprono un'area del mondo, non corrono verso la meta e non controllano la percorribilità del percorso. Tra la selezione e l'elaborazione del server, lo stato del mondo può cambiare.
La trasmissione di true e 1 è equivalente anche per i flag, false e 0. Anche altri numeri diversi da zero si convertono in true, ma 8/9 non sono modalità separate; usa chiaro true/false.
Ordine esatto: notorietà, distanza, più vicino, maxZ, body, colore, includeSelf. Diverso da AttackNearest e GetMobiles.
Non ci sono parametri classMask, aliveOnly o visibleOnly. Se necessario, controllare separatamente il ID trovato; per selezionare tra tutti quelli vivi/visibili, utilizzare GetMobiles in modo che quello morto più vicino non oscuri gli altri.

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

1. Trova e salva l'alleato più vicino: script diretto

Parametri e flusso di esecuzione:

2 - Alleato, 12 - raggio. Il resto: più vicino=true, maxZ=FindVertical(), qualsiasi body/hue, self escluso. La squadra salva solo il bersaglio, non attacca.

var ally = UO.FindMan(2, 12);
if (Truth(ally == 0))
{
    return null;
}
UO.AddObject("ally_nearby", ally);

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

2. Specificare ciascuna condizione prima di ulteriori azioni: funzione dello script

Parametri e flusso di esecuzione:

Il controllo IsDead è stato eseguito separatamente. body specifica gli organi; bodyHue=-1 non li limita a hue. Questa squadra non si classifica in base all'abbigliamento.

return  RunScenario();
 object? RunScenario()
{
    var status = 5;
    var radius = 8;
    dynamic nearest = true;
    var height = 4;
    var bodies = "0x0190|0x0191";
    var bodyHue = -1;
    dynamic includeMe = false;
    var enemy = UO.FindMan(status, radius, nearest, height, bodies, bodyHue, includeMe);
    if (Truth(enemy != 0))
    {
        if (Truth(UO.IsDead(enemy) == 0))
        {
            UO.Attack(enemy);
        }
    }

    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. Trova prima mobile con la specifica classe di script hue

Parametri e flusso di esecuzione:

Il primo -1 disabilita la notorietà, il secondo -1 disabilita body. false in terza posizione disattiva l'ordinamento; l'ultimo false esclude self. La tonalità degli abiti non viene controllata.

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 chosenHue = 0x0455;
        var mobile = UO.FindMan(-1, 10, false, 8, -1, chosenHue, false);
        if (Truth(mobile == 0))
        {
            return null;
        }

        UO.AddObject("body_hue_match", 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;
}

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

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetMobiles: bridge.GetMobiles().
InjectionScript.Runtime.State.RuntimeDictionary.Set: state.Objects.Set(arguments.Length > 0 ? Text(0) : "findman", mobile).
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Text: Text(0).

Codice interno di implementazione; non è uno script autonomo.

case "findman":

                {

                    int mobile = bridge.GetMobiles().FirstOrDefault();

                    if (mobile != 0) state.Objects.Set(arguments.Length > 0 ? Text(0) : "findman", mobile);

                    break;

                }

`UO.FindMan(notoriety)` — `UO.FindMan(Any)`

Parametri: notoriety (Any)

Risultato: dynamic / Any.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.RegisterCompactSearchApi [FindMan].
InjectionScript.Runtime.InjectionApiUO.CompactFindMan: CompactFindMan(values).

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(CompactFindMan(values))

`UO.FindMan(notoriety, distance)` — `UO.FindMan(Any,Any)`

Parametri: notoriety (Any), distance (Any)

Risultato: dynamic / Any.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.RegisterCompactSearchApi [FindMan].
InjectionScript.Runtime.InjectionApiUO.CompactFindMan: CompactFindMan(values).

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(CompactFindMan(values))

`UO.FindMan(notoriety, distance, nearest)` — `UO.FindMan(Any,Any,Any)`

Parametri: notoriety (Any), distance (Any), nearest (Any)

Risultato: dynamic / Any.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.RegisterCompactSearchApi [FindMan].
InjectionScript.Runtime.InjectionApiUO.CompactFindMan: CompactFindMan(values).

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(CompactFindMan(values))

`UO.FindMan(notoriety, distance, nearest, maxZ)` — `UO.FindMan(Any,Any,Any,Any)`

Parametri: notoriety (Any), distance (Any), nearest (Any), maxZ (Any)

Risultato: dynamic / Any.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.RegisterCompactSearchApi [FindMan].
InjectionScript.Runtime.InjectionApiUO.CompactFindMan: CompactFindMan(values).

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(CompactFindMan(values))

`UO.FindMan(notoriety, distance, nearest, maxZ, body)` — `UO.FindMan(Any,Any,Any,Any,Any)`

Parametri: notoriety (Any), distance (Any), nearest (Any), maxZ (Any), body (Any)

Risultato: dynamic / Any.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.RegisterCompactSearchApi [FindMan].
InjectionScript.Runtime.InjectionApiUO.CompactFindMan: CompactFindMan(values).

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(CompactFindMan(values))

`UO.FindMan(notoriety, distance, nearest, maxZ, body, color)` — `UO.FindMan(Any,Any,Any,Any,Any,Any)`

Parametri: notoriety (Any), distance (Any), nearest (Any), maxZ (Any), body (Any), color (Any)

Risultato: dynamic / Any.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.RegisterCompactSearchApi [FindMan].
InjectionScript.Runtime.InjectionApiUO.CompactFindMan: CompactFindMan(values).

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(CompactFindMan(values))

`UO.FindMan(notoriety, distance, nearest, maxZ, body, color, includeSelf)` — `UO.FindMan(Any,Any,Any,Any,Any,Any,Any)`

Parametri: notoriety (Any), distance (Any), nearest (Any), maxZ (Any), body (Any), color (Any), includeSelf (Any)

Risultato: dynamic / Any.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.RegisterCompactSearchApi [FindMan].
InjectionScript.Runtime.InjectionApiUO.CompactFindMan: CompactFindMan(values).

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(CompactFindMan(values))

UO.FindMobile

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

Firme C#

int UO.FindMobile();
int UO.FindMobile(object? stateFilter);
int UO.FindMobile(object? stateFilter, object? rangeFilter);
int UO.FindMobile(object? stateFilter, object? rangeFilter, object? verticalFilter);
int UO.FindMobile(object? stateFilter, object? rangeFilter, object? verticalFilter, object? directionOrKind);
int UO.FindMobile(object? stateFilter, object? rangeFilter, object? verticalFilter, object? directionFilter, object? kindFilter);

Trova il personaggio/creatura caricato più vicino utilizzando filtri di stringhe congiunte. Escluso il giocatore stesso.

Parametri

stateFilter - Di solito tutti/vivi/morti; opzionale. Tutti gli argomenti nell'implementazione sono stringhe di filtro, quindi è accettabile combinare più parole in un unico argomento.
rangeFilter - Tipicamente tutto / vicino (0..4) / medio (5..9) / lontano (da 10 al raggio totale). Il raggio numerico non è accettato in questa posizione; il limite complessivo cambia attraverso UO.FindDistance(value).
verticalFilter - tutto / sopra / sotto. sopra: candidato.Z > self.Z, sotto: candidato.Z < self.Z. Questo non è un pavimento o una tolleranza numerica Z.
directionOrKind — La quarta posizione del modulo con quattro argomenti: tutti, nord/sud/est/ovest o umano/npc/mob. Può essere una stringa composta.
directionFilter — La quarta posizione del modulo con cinque argomenti: tutto o il confronto X/Y nord/sud/est/ovest. Questa è la posizione relativa a self, non la direzione della visuale.
kindFilter - Quinta posizione: all/human/npc/mob. l'umano include corpi maschili e femminili: 0x0190 - umano maschio, 0x0191 - umano femminile, così come i corpi standard di elfo/gargoyle e fantasma. Elenco completo: umano. npc - IsNpc e umano; mob - IsNpc e NON umano. Le parole mostro e femmina non sono accettate.

Valore restituito

int: serial di uno mobile, o 0 se non ci sono corrispondenze. Non è una quantità, non un array, non type e non bool. Controllo trovato != 0 indica la presenza del risultato; confronto trovato == true non è valido in C#: int non è paragonabile a bool.

Comportamento

Si applica agli argomenti da UO.FindMobile: da 0 a 5. Gli argomenti sulla coda mancanti sono tutti. Ogni argomento può contenere una o più parole separate da spazio, tabulazione, virgola, punto e virgola, | o +. Tutte le condizioni sono combinate tramite AND; simbolo | non significa OR qui.
La ricerca considera solo i cellulari scaricati, esclude self e limita la distanza al massimo (1, UO.FindDistance()). La distanza viene misurata secondo la regola max(abs(dx), abs(dy)); un quadrato diagonale conta come uno. Per gli oggetti in movimento, la distanza può tenere conto della coda di passi e i confronti X/Y/Z leggono le coordinate attuali.
Si seleziona quello più vicino tra quelli idonei; a uguale distanza - più piccolo serial. Restituisce int serial o 0 anziché true/false, conteggio o matrice.
UO.FindMobile non modifica FindItem/FindCount/GetFoundItems, non si applica Ignore e UO.FindVertical e non controlla la visibilità, la transitabilità o la linea di vista. Non sposta, prende di mira o carica oggetti remoti.
I raggi numerici/Z/direzioni, le parole mostro, nord-est, nord-ovest, sud-est, sud-ovest non sono filtri. Una parola sconosciuta provoca un errore durante il controllo di un candidato; in assenza di candidati la presente sezione potrebbe non essere eseguita. Per un'area diagonale, combina nord-est, ecc.; per la verifica numerica, utilizzare le proprietà degli oggetti trovati o UO.GetMobiles().

Script C# autonomi

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

1. Cerca e controlla il risultato: script diretto

Parametri e flusso di esecuzione:

Superato tutto, tutto, sopra: l'altezza dell'oggetto è strettamente maggiore della Z del personaggio. Z uguale non è adatto.
0 viene elaborato prima che le proprietà vengano lette. Print mostra ID, nome e altezze; non viene attivata alcuna azione di gioco.

var found = UO.FindMobile("all", "all", "above");
if (Truth(found == 0))
{
    UO.Print("No matching mobile");
    return null;
}
UO.Print("ID: " + Convert.ToString(found) + " | Name: " + UO.GetName(found));
UO.Print("Z: " + Convert.ToString(UO.GetZ(found)) + " | Self Z: " + Convert.ToString(UO.GetZ("self")));

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

2. Combinazione di condizioni con raggio temporale - funzione script

Parametri e flusso di esecuzione:

18—limite esterno; vivo, vicino, tutto, tutto, la folla stabilisce condizioni cooperative. vicino rimane l'intervallo fino a 4, medio - 5..9, lontano - da 10.
Infine restituisce il raggio precedente in caso di completamento normale o di errore gestito. Lo script non espande il caricamento del mondo.

return  RunScenario();
 object? RunScenario()
{
    var previous = UO.FindDistance();
    try
    {
        UO.FindDistance(18);
        var found = UO.FindMobile("alive", "near", "all", "all", "mob");
        if (Truth(found != 0))
        {
            UO.Print("Match: " + Convert.ToString(found));
            UO.Print("Distance: " + Convert.ToString(UO.GetDistance(found)));
        }
        else
        {
            UO.Print("No match in the loaded area");
        }
    }
    finally
    {
        UO.FindDistance(previous);
    }

    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 per filtro composito - Classe Script

Parametri e flusso di esecuzione:

La stringa "nord-est" viene passata all'helper. Queste sono diverse condizioni di una richiesta e non una ricerca sequenziale di obiettivi diversi.
FindAndDescribe è dichiarato nella sua interezza. Restituisce ID/0 senza modificare il bersaglio o il carattere.

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 = FindAndDescribe("north east");
        UO.Print("Returned ID: " + Convert.ToString(id));
        return null;
    }

    dynamic FindAndDescribe(dynamic filters)
    {
        var id = UO.FindMobile(filters);
        if (Truth(id == 0))
        {
            UO.Print("Nothing matched: " + filters);
            return 0;
        }

        UO.Print(UO.GetName(id) + " | " + Convert.ToString(id));
        return id;
    }

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

4. Trova la creatura e controlla separatamente la distanza esatta - sceneggiatura diretta

Parametri e flusso di esecuzione:

vivo/tutti/tutti/tutti/mob - cinque posizioni supportate. La distanza 2 viene controllata dopo aver ottenuto il risultato più vicino.
Tale script non controlla il percorso verso la creatura e non inizia a muoversi.

var found = UO.FindMobile("alive", "all", "all", "all", "mob");
if (Truth(found == 0))
{
    UO.Print("No loaded creature");
    return null;
}
if (Truth(UO.GetDistance(found) <= 2))
{
    UO.Print("Creature within two tiles: " + Convert.ToString(found));
}
else
{
    UO.Print("Nearest creature is farther away");
}

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

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.FindMobile.
InjectionScript.Runtime.InjectionApiUO.FindMobile: FindMobile(new InjectionValue("all"), new InjectionValue("all"), new InjectionValue("all"), new InjectionValue("all")).

Codice interno di implementazione; non è uno script autonomo.

public int FindMobile() => FindMobile(new InjectionValue("all"), new InjectionValue("all"),

            new InjectionValue("all"), new InjectionValue("all"));

`UO.FindMobile(stateFilter)` — `UO.FindMobile(Any)`

Parametri: stateFilter (Any)

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.FindMobile.
InjectionScript.Runtime.InjectionApiUO.FindMobile: FindMobile(stateFilter, new InjectionValue("all"), new InjectionValue("all"), new InjectionValue("all")).

Codice interno di implementazione; non è uno script autonomo.

public int FindMobile(InjectionValue stateFilter) => FindMobile(stateFilter, new InjectionValue("all"),

            new InjectionValue("all"), new InjectionValue("all"));

`UO.FindMobile(stateFilter, rangeFilter)` — `UO.FindMobile(Any,Any)`

Parametri: stateFilter (Any), rangeFilter (Any)

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.FindMobile.
InjectionScript.Runtime.InjectionApiUO.FindMobile: FindMobile(stateFilter, rangeFilter, new InjectionValue("all"), new InjectionValue("all")).

Codice interno di implementazione; non è uno script autonomo.

public int FindMobile(InjectionValue stateFilter, InjectionValue rangeFilter) => FindMobile(stateFilter,

            rangeFilter, new InjectionValue("all"), new InjectionValue("all"));

`UO.FindMobile(stateFilter, rangeFilter, verticalFilter)` — `UO.FindMobile(Any,Any,Any)`

Parametri: stateFilter (Any), rangeFilter (Any), verticalFilter (Any)

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.FindMobile.
InjectionScript.Runtime.InjectionApiUO.FindMobile: FindMobile(stateFilter, rangeFilter, verticalFilter, new InjectionValue("all")).

Codice interno di implementazione; non è uno script autonomo.

public int FindMobile(InjectionValue stateFilter, InjectionValue rangeFilter, InjectionValue verticalFilter) =>

            FindMobile(stateFilter, rangeFilter, verticalFilter, new InjectionValue("all"));

`UO.FindMobile(stateFilter, rangeFilter, verticalFilter, directionOrKind)` — `UO.FindMobile(Any,Any,Any,Any)`

Parametri: stateFilter (Any), rangeFilter (Any), verticalFilter (Any), directionOrKind (Any)

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Register [FindMobile].
InjectionScript.Runtime.InjectionApiUO.FindMobile: FindMobile(values[0], values[1], values[2], values[3]).

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(

                    FindMobile(values[0], values[1], values[2], values[3]))

`UO.FindMobile(stateFilter, rangeFilter, verticalFilter, directionFilter, kindFilter)` — `UO.FindMobile(Any,Any,Any,Any,Any)`

Parametri: stateFilter (Any), rangeFilter (Any), verticalFilter (Any), directionFilter (Any), kindFilter (Any)

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Register [FindMobile].
InjectionScript.Runtime.InjectionApiUO.FindMobile: FindMobile(values[0], values[1], values[2], values[3], values[4]).

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(

                    FindMobile(values[0], values[1], values[2], values[3], values[4]))

UO.FindNotoriety

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

Firme C#

dynamic UO.FindNotoriety(object? @type, object? notoriety);
dynamic UO.FindNotoriety(object? @type, object? notoriety, object? distance);
dynamic UO.FindNotoriety(object? @type, object? notoriety, object? distance, object? nearest);
dynamic UO.FindNotoriety(object? @type, object? notoriety, object? distance, object? nearest, object? maxZ);
dynamic UO.FindNotoriety(object? @type, object? notoriety, object? distance, object? nearest, object? maxZ, object? color);
dynamic UO.FindNotoriety(object? @type, object? notoriety, object? distance, object? nearest, object? maxZ, object? color, object? container);

Cerca un altro mobile uno per uno body/type e notorietà consentita. Adatto quando serve un certo tipo di carattere con l'atteggiamento giusto; le forme avanzate ti consentono di vincolare raggio, altezza e hue. Questa è solo una selezione di oggetti, non un attacco.

Parametri

type — Un corpo numerico graphic o stringa esadecimale; non serial, non type dell'oggetto indossato e non dell'array. 0x0190 (400) - maschio umano, 0x0191 (401) - femmina umana; Questi sono filtri di precisione diversi. I due body richiedono chiamate separate oppure GetMobiles con maschera. -1 o 0xFFFF - qualsiasi corpo.
notoriety — Stato della relazione con il personaggio ricevuto dal server: 0 — sconosciuto, 1 — Innocente, 2 — Alleato, 3 — Grigio, 4 — Criminale, 5 — Nemico, 6 — Assassino, 7 - Invulnerabile. Il numero indica uno stato; "5|6" o un array di numeri - uno qualsiasi dei precedenti. Non è il colore dei vestiti o la classe. Un numero negativo (di solito -1), 0xFFFF, "qualsiasi", una stringa vuota o un array vuoto disabilitano separatamente questo filtro. Una stringa non valida senza numeri validi non trova nessuno. L'ordine degli stati non stabilisce la priorità. Il filtro 5 seleziona il nemico invece di selezionare automaticamente qualsiasi NPC/mostro; i valori effettivi dipendono dal server. Più valori vengono combinati come OR: il numero 5, la stringa "5|6" o un array semplice di numeri/stringhe numeriche. È possibile combinare array flat e argomenti individuali. L’ordine dei valori non dà priorità. Sono esclusi i token non numerici; una maschera completamente errata non trova nulla. Gli array nidificati non sono numeri e vengono ignorati come elementi non validi; le maschere multidimensionali non sono supportate. Caratteristica della forma numerica a due argomenti: solo un codice negativo disabilita il filtro, il numerico 0xFFFF è considerato un codice letterale e solitamente non trova nessuno.
distance — Raggio orizzontale nelle celle compreso: 5 consente la distanza 0..5. La distanza è max(abs(dx),abs(dy)), quindi anche la diagonale adiacente è 1. Per impostazione predefinita o se il numero è negativo, viene utilizzato UO.FindDistance() anziché la ricerca illimitata. 0 lascia la stessa cella X/Y. Non la lunghezza del percorso; gli ostacoli e i pavimenti non vengono controllati da questo parametro.
nearest - false/0 default: prima corrispondenza nell'ordine di enumerazione mondiale, nessuna garanzia di ID più vicino o più piccolo. true/1: più vicino, se uguale, più piccolo serial.
maxZ — Massimi addominali (Z del bersaglio - Z del proprio personaggio), inclusi, in unità Z del mondo. Questo non è il numero di piani o di celle X/Y. maxZ=4 con il giocatore Z 10 consente il bersaglio Z 6..14; 0 richiede esattamente la stessa altezza. Per impostazione predefinita/per un numero negativo, viene preso UO.FindVertical(). Sulle scale, una Z uguale può eliminare il bersaglio desiderato. Anche una piccola differenza in Z non dimostra l'accessibilità del pavimento.
color — Tonalità di mobile stesso: int o stringa numerica/esadecimale. Numero negativo (-1 per impostazione predefinita) e 0xFFFF - qualsiasi hue; 0 è esattamente hue 0 e non un valore qualsiasi. Non il colore della striscia della notorietà o la tonalità dei vestiti. Questo parametro non controlla il colore del capo indossato.
container - Assente per impostazione predefinita: mondo. Quando specificati, ground/"ground"/UO.Ground(), i numeri 0/1 e -1/"my" sono accettabili come designazioni di mondo compatibili in questo particolare comando. Un contenitore serial o "backpack" esplicito restituisce 0: non ci sono cellulari all'interno del contenitore. Non aggiunge la ricerca di cose.

Valore restituito

int - serial del mobile selezionato o 0 se non ce n'è uno adatto. Questo è ID, non graphic/type, il numero di oggetti trovati o true/false: usa if (found != 0) { ... }, not find == true. Un ID trovato può essere passato a UO.AddObject, UO.Attack o UO.Follow, ma ogni azione di gioco viene chiamata separatamente.

Comportamento

La ricerca legge solo i cellulari già scaricati dal client; sono esclusi i record distrutti e Ignore. La chiamata stessa non apre la destinazione, non attacca, non raggiunge la destinazione e non richiede oggetti remoti dal server.
La distanza è geometrica max(abs(dx),abs(dy)), non la lunghezza del percorso. La vicinanza non garantisce l'assenza di un muro o l'accessibilità ad un altro piano. Le condizioni possono cambiare al momento della restituzione.
La vita, la furtività e la linea di vista non vengono controllate automaticamente. Se sono importanti, usa GetMobiles con aliveOnly/visibleOnly o i tuoi controlli. Avere un server con lo stato Nemico non rende idoneo alcun NPC.
Da 2 a 7 argomenti. Per trasmettere maxZ è necessario specificare la distanza precedente e quella più vicina. Per una maggiore notorietà in questo comando, utilizzare una singola maschera "5|6" o un array piatto nel secondo argomento; il terzo argomento è la distanza, non il secondo status.
Un'importante differenza nella forma: due argomenti con notorietà NUMERICA chiamano bridge.FindNotoriety, scartando il vecchio FindItem/FindCount/GetFoundItems e registrando tutte le corrispondenze. Due argomenti STRINGA/ARARIO, così come qualsiasi forma con argomenti 3..7, restituiscono solo ID, mantenendo gli stessi campi Trova*. Non leggere FindCount come risultato di una query estesa.
Tutte le forme escludono self e Ignore, usa il limite Z; filtri live/visibili e nessuna linea di vista. Nessuna corrispondenza ritorna 0. type/distance/maxZ/color illeggibile causa un errore di conversione.

Script C# autonomi

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

1. Conta uomini e donne con reputazione nemica - sceneggiatura diretta

Parametri e flusso di esecuzione:

0x0190 (400) è un corpo umano maschile, 0x0191 (401) è un corpo umano femminile. 5 - Nemico. Ogni chiamata riceve UNO body; la stringa 0x0190|0x0191 non è supportata in questa posizione. Vengono utilizzati gli attuali FindDistance/FindVertical.
Dopo la seconda chiamata, FindItem/FindCount/GetFoundItems si riferiscono solo ai corpi femminili; la prima quantità viene memorizzata in menCount. L'uomo/donna restituito è il primo serial o 0, non il numero. Nel risultato può essere incluso anche NPC con tali organismi; i fantasmi e le altre razze non sono inclusi in questi due body.

var man = UO.FindNotoriety(0x0190, 5);
var menCount = UO.FindCount();
var woman = UO.FindNotoriety(0x0191, 5);
var womenCount = UO.FindCount();
UO.Print("Male humans: " + Convert.ToString(menCount));
UO.Print("Female humans: " + Convert.ToString(womenCount));
UO.Print("Total humans: " + Convert.ToString(menCount + womenCount));

2. Il più vicino dei due stati con altezza limitata: funzione script

Parametri e flusso di esecuzione:

-1 nel primo parametro — qualsiasi organismo; -1 nel sesto - qualsiasi hue. ground - pace. FindCount non è stato aggiornato da questo modulo; uso trovato.

return  RunScenario();
 object? RunScenario()
{
    var found = UO.FindNotoriety(-1, "5|6", 12, true, 4, -1, "ground");
    if (Truth(found != 0))
    {
        UO.AddObject("near_enemy", found);
    }

    return null;
}

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

3. Matrice di stati nel secondo parametro: classe di scenario

Parametri e flusso di esecuzione:

L'array contiene due codici. Gli argomenti di coda mancanti indicano il raggio corrente/Z, il più vicino=false e qualsiasi hue. Questa non è la voce UO.FindNotoriety(type,5,6): lì 6 sarebbe il raggio.

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()
    {
        dynamic[] allowed = new dynamic[checked((int)(1) + 1)];
        allowed[0] = 5;
        allowed[1] = 6;
        var found = UO.FindNotoriety(0x0191, allowed);
        if (Truth(found != 0))
        {
            UO.AddObject("allowed_mobile", found);
            UO.Print("Selected ID: " + Convert.ToString(found));
        }

        return null;
    }

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

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.FindNotoriety(type, notoriety)` — `UO.FindNotoriety(Any,Any)`

Parametri: type (Any), notoriety (Any)

Risultato: dynamic / Any.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.RegisterCompactSearchApi [FindNotoriety].
InjectionScript.Runtime.InjectionApiUO.CompactFindNotoriety: CompactFindNotoriety(values).

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(CompactFindNotoriety(values))

`UO.FindNotoriety(type, notoriety, distance)` — `UO.FindNotoriety(Any,Any,Any)`

Parametri: type (Any), notoriety (Any), distance (Any)

Risultato: dynamic / Any.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.RegisterCompactSearchApi [FindNotoriety].
InjectionScript.Runtime.InjectionApiUO.CompactFindNotoriety: CompactFindNotoriety(values).

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(CompactFindNotoriety(values))

`UO.FindNotoriety(type, notoriety, distance, nearest)` — `UO.FindNotoriety(Any,Any,Any,Any)`

Parametri: type (Any), notoriety (Any), distance (Any), nearest (Any)

Risultato: dynamic / Any.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.RegisterCompactSearchApi [FindNotoriety].
InjectionScript.Runtime.InjectionApiUO.CompactFindNotoriety: CompactFindNotoriety(values).

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(CompactFindNotoriety(values))

`UO.FindNotoriety(type, notoriety, distance, nearest, maxZ)` — `UO.FindNotoriety(Any,Any,Any,Any,Any)`

Parametri: type (Any), notoriety (Any), distance (Any), nearest (Any), maxZ (Any)

Risultato: dynamic / Any.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.RegisterCompactSearchApi [FindNotoriety].
InjectionScript.Runtime.InjectionApiUO.CompactFindNotoriety: CompactFindNotoriety(values).

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(CompactFindNotoriety(values))

`UO.FindNotoriety(type, notoriety, distance, nearest, maxZ, color)` — `UO.FindNotoriety(Any,Any,Any,Any,Any,Any)`

Parametri: type (Any), notoriety (Any), distance (Any), nearest (Any), maxZ (Any), color (Any)

Risultato: dynamic / Any.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.RegisterCompactSearchApi [FindNotoriety].
InjectionScript.Runtime.InjectionApiUO.CompactFindNotoriety: CompactFindNotoriety(values).

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(CompactFindNotoriety(values))

`UO.FindNotoriety(type, notoriety, distance, nearest, maxZ, color, container)` — `UO.FindNotoriety(Any,Any,Any,Any,Any,Any,Any)`

Parametri: type (Any), notoriety (Any), distance (Any), nearest (Any), maxZ (Any), color (Any), container (Any)

Risultato: dynamic / Any.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.RegisterCompactSearchApi [FindNotoriety].
InjectionScript.Runtime.InjectionApiUO.CompactFindNotoriety: CompactFindNotoriety(values).

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(CompactFindNotoriety(values))

UO.FindQuantity

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

Firme C#

dynamic UO.FindQuantity();

Legge la quantità corrente nel primo risultato della ricerca.

Parametri

Non ci sono parametri.

Valore restituito

int - Importo attuale dell'articolo con serial FindItem, 1 per un personaggio esistente, 0 per un oggetto mancante/eliminato. Gli altri stack trovati non sono cumulativi. A differenza di FindFullQuantity, la quantità viene letta dall'oggetto corrente quando viene chiamato.

Comportamento

I dati appartengono all'ultima ricerca normale di questo script. FindType con argomenti 1–5, FindTypeEx, Count/CountEx/CountGround sostituiscono i risultati. Non sono necessari comandi avanzati di caratteri filtrati per modificare questa istantanea.
Una nuova ricerca senza corrispondenze cancella FindItem, FindCount e FindFullQuantity e cancella GetFoundItems. La sola lettura di un risultato non attiva una nuova ricerca.

Script C# autonomi

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.

UO.FindType(0x0EED, -1, "backpack");
object? result = UO.FindQuantity();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

1. Misura i risultati della ricerca sull'oro: script diretto

Parametri e flusso di esecuzione:

type=0x0EED – oro; colore=-1 — qualsiasi hue; backpack - solo il contenuto diretto dello zaino in questo formato FindType.
int - Importo attuale dell'articolo con serial FindItem, 1 per un personaggio esistente, 0 per un oggetto mancante/eliminato. Gli altri stack trovati non sono cumulativi. A differenza di FindFullQuantity, la quantità viene letta dall'oggetto corrente quando viene chiamato.

var found = UO.FindType(0x0EED, -1, "backpack");
var value = UO.FindQuantity();
UO.Print(Convert.ToString(value));

2. Confronta elementi e unità - Funzione script

Parametri e flusso di esecuzione:

Tutte e quattro le letture appartengono a una ricerca finché non viene richiamata un'altra ricerca nel mezzo.
Ad esempio, due pile di 50: Oggetti=2, Prima pila=50, Tutte le unità=100; Il primo ID contiene l'unico ID di uno stack.

return  RunScenario();
 object? RunScenario()
{
    var found = UO.FindType(0x0EED, -1, "backpack");
    UO.Print("Items: " + Convert.ToString(UO.FindCount()));
    UO.Print("First stack: " + Convert.ToString(UO.FindQuantity()));
    UO.Print("All units: " + Convert.ToString(UO.FindFullQuantity()));
    UO.Print("First ID: 0x" + Hex(UO.FindItem()));
    return null;
}

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

3. Salva il risultato fino alla ricerca successiva - classe di script

Parametri e flusso di esecuzione:

Il primo type è oro, il secondo 0x0F7A è un tipo separato di reagente. La nuova squadra cambia l'inquadratura complessiva.
salvato rimane il numero della prima ricerca. La seconda lettura si applica al reagente anche se non c'è corrispondenza.

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 found = UO.FindType(0x0EED, -1, "backpack");
        var saved = UO.FindQuantity();
        found = UO.FindType(0x0F7A, -1, "backpack");
        UO.Print("Saved: " + Convert.ToString(saved));
        UO.Print("Current: " + Convert.ToString(UO.FindQuantity()));
        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.FindQuantity()` — `UO.FindQuantity()`

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "findquantity": return new InjectionValue(bridge.FindQuantity());

UO.FindType

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

Firme C#

string UO.FindType(object? @type);
string UO.FindType(object? @type, object? color);
string UO.FindType(object? @type, object? color, object? container);
string UO.FindType(object? @type, object? color, object? container, object? range);
string UO.FindType(object? @type, object? color, object? container, object? distance, object? recursive);
string UO.FindType(object? @type, object? color, object? container, object? distance, object? notoriety, object? nearest);
string UO.FindType(object? @type, object? color, object? container, object? distance, object? notoriety, object? nearest, object? maxZ);
string UO.FindType(object? @type, object? color, object? container, object? distance, object? notoriety, object? nearest, object? maxZ, object? mobileOnly);
string UO.FindType(object? @type, object? color, object? container, object? distance, object? notoriety, object? nearest, object? maxZ, object? mobileOnly, object? itemOnly);
string UO.FindType(object? @type, object? color, object? container, object? distance, object? notoriety, object? nearest, object? maxZ, object? mobileOnly, object? itemOnly, object? includeIgnored);
string UO.FindType(object? @type, object? color, object? container, object? distance, object? notoriety, object? nearest, object? maxZ, object? mobileOnly, object? itemOnly, object? includeIgnored, object? includeSelf);
string UO.FindType(object? @type, object? color, object? container, object? distance, object? notoriety, object? nearest, object? maxZ, object? mobileOnly, object? itemOnly, object? includeIgnored, object? includeSelf, object? aliveOnly);
string UO.FindType(object? @type, object? color, object? container, object? distance, object? notoriety, object? nearest, object? maxZ, object? mobileOnly, object? itemOnly, object? includeIgnored, object? includeSelf, object? aliveOnly, object? visibleOnly);
string UO.FindType(object? @type, object? color, object? container, object? distance, object? notoriety, object? nearest, object? maxZ, object? mobileOnly, object? itemOnly, object? includeIgnored, object? includeSelf, object? aliveOnly, object? visibleOnly, object? nameMask);

Cerca tra oggetti e personaggi già scaricati dal client. Puoi effettuare la ricerca per tipologia, colore, contenitore, distanza e filtri aggiuntivi. Il risultato è la stringa esadecimale serial dell'oggetto selezionato; una stringa vuota indica nessuna corrispondenza. Il comando stesso non apre i contenitori, non raccoglie oggetti e non attacca il bersaglio trovato.

Parametri

type - Un elemento graphic o carattere body: numero intero o stringa numerica. 0x0EED - oro; 0x0190 (400) - maschio umano; 0x0191 (401) - donna umana. Uno type 0x0190 non include 0x0191. Per elencare i caratteri di entrambi i sessi, usa GetMobiles con body="0x0190|0x0191"; la maschera non viene passata a questo singolo argomento FindType. Un valore negativo o 0xFFFF cancella il filtro del tipo.
color - Tonalità/colore: intero o stringa numerica. -1 o 0xFFFF significa qualsiasi colore; 0 - in particolare hue 0. Caratteristica della forma a due argomenti: le righe "ground", "backpack", "my" nella seconda posizione selezionano l'area di ricerca invece del colore. "my" abilita il bypass dei sottocontenitori caricati.
container - Area di ricerca: "ground" - il mondo, "backpack" - il livello più alto del tuo zaino, "my" - uno zaino con sottocontenitori caricati in forma breve; Puoi anche passare serial del contenitore o il nome salvato dell'oggetto. I contenitori non si aprono automaticamente. Le forme estese 7–14 degli argomenti ripetono il contenuto diretto del contenitore specificato e non hanno un flag ricorsivo.
range — Il quarto argomento della forma a quattro argomenti: distanza nelle celle. Un valore negativo utilizza l'impostazione generale FindDistance; 0 lascia solo le corrispondenze sulla stessa cella. Per un articolo in un contenitore, viene presa in considerazione la posizione del contenitore nel mondo.
distance — Distanza nelle celle nella posizione 4 sotto forma di cinque argomenti. -1 utilizza FindDistance; il numero 0 e superiore imposta un limite esplicito. Questo è il raggio di ricerca, non la lunghezza del percorso.
recursive - SOLO il quinto argomento sotto forma di cinque argomenti: 1/true - cerca anche nei sottocontenitori caricati, 0/false - solo il livello superiore. Questa non è notorietà. Passando alla forma a sei argomenti cambia il significato della posizione 5.
notoriety — Posizione di 5 nelle forme argomentative 6–14. Reputazione del personaggio: 0 sconosciuto, 1 innocente, 2 alleato, 3 attaccabile, 4 criminale, 5 nemico, 6 assassino, 7 invulnerabile. Puoi passare un numero, la stringa "3|6" o un array di valori. -1, 0xFFFF o "qualsiasi" disabilita il filtro. Quando il filtro è attivo gli articoli vengono esclusi: non hanno notorietà.
nearest - Posizione 6: 1/true - seleziona il carattere adatto più vicino e nella forma estesa 7–14 - il candidato più vicino di qualsiasi tipo consentito; se la distanza è uguale, viene utilizzato serial. 0/false preserva l'ordine di ricerca. Nella forma a sei argomenti, quando si procede alla ricerca degli elementi viene utilizzato il normale ordine di ricerca degli elementi.
maxZ - Posizione 7: massimo dislivello assoluto in Z con proprio carattere. 0 - stessa altezza; -1 prende FindVertical. Per gli articoli all'interno di un contenitore, viene controllata l'altezza del contenitore. Questo non è un numero di piano.
mobileOnly — Posizione 8: 1/true — lascia solo personaggi e mob; 0/false - consente anche gli oggetti. Se non ci sono argomenti, false.
itemOnly — Posizione 9: 1/true — lascia solo oggetti; 0/false - consente anche i caratteri. Se mancante, false. Contemporaneamente mobileOnly=true e itemOnly=true danno un risultato vuoto.
includeIgnored — Posizione 10: 1/true — consente oggetti da IgnoreList; 0/false - escludili. L'impostazione predefinita è false. Il comando IgnoreList in sé non cambia.
includeSelf — Posizione 11: 1/true — consenti il tuo personaggio tra i candidati mobile; 0/false - escludi. L'impostazione predefinita è false. Non influisce sugli articoli.
aliveOnly - Posizione 12: 1/true - esclude i caratteri morti; 0/false - consente entrambi gli stati. L'impostazione predefinita è false. Questo filtro non controlla lo stato dell'articolo.
visibleOnly - Posizione 13: 1/true - richiede controllo positivo IsVisible; 0/false - non utilizzarlo. L'impostazione predefinita è false. Il comando funziona ancora solo con oggetti noti al client.
nameMask — Posizione 14: parte testuale del nome, senza distinzione tra maiuscole e minuscole. La stringa "orc|troll" consente entrambe le corrispondenze; i delimitatori possono anche essere virgole e punti e virgola. Una stringa vuota, "qualsiasi" o "-1" rimuove il filtro. Questa è una ricerca di sottostringhe, non un'espressione regolare o una maschera con *. Se manca l'argomento, il filtro è disabilitato.

Valore restituito

string: ad esempio "0x40001234". Se non viene trovato nulla - "". Controlla il risultato confrontandolo con una stringa vuota. Non confonderlo con il numero di oggetti trovati o il numero di passaggi per raggiungerli.

Comportamento

Esistono moduli con argomenti 1–14, ma questa non è una firma lunga con parametri omessi arbitrariamente. Seleziona la riga di sintassi esatta; gli argomenti vengono passati in modo posizionale.
I moduli 1–5 utilizzano la ricerca normale e aggiornano FindItem/FindCount/ elenco dei risultati. Per i moduli 6–14, utilizzare direttamente la stringa restituita: il filtraggio dei caratteri viene eseguito in modo separato e non promette di aggiornare questi valori condivisi.
Per le forme brevi, per impostazione predefinita la ricerca è nel mondo, qualsiasi colore, distanza FindDistance, senza ricorsione. La stringa "my" è una forma abbreviata speciale per uno zaino con sottocontenitori.
La forma a sei argomenti cerca innanzitutto un carattere corrispondente; In assenza di un filtro di notorietà e di un personaggio adatto, è possibile la ricerca di oggetti. I moduli 7–14 combinano i candidati risolti e applicano filtri aggiuntivi.
Particolarmente importante è la modifica del numero degli argomenti da cinque a sei: il ricorsivo viene sostituito dalla notorietà e il più vicino diventa il sesto argomento. Il valore 1 nella posizione 5 significa quindi attraversamento innocente, non ricorsivo.

Script C# autonomi

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

1. Trova l'oro nel livello più alto dello zaino ed elabora la mancanza di risultato - sceneggiatura diretta

Parametri e flusso di esecuzione:

1: type=0x0EED - alla ricerca dell'oro.
2: colore=-1 — qualsiasi hue.
3: container="backpack" - solo il contenuto diretto del tuo zaino.
l'oro riceve la stringa serial. Il segno gold="" separa l'oggetto mancante dall'oggetto trovato. Info(oro) visualizza le informazioni; l'oro non si muove.

var gold = UO.FindType(0x0EED, -1, "backpack");
if (Truth(gold == ""))
{
    UO.Print("Gold was not found in the loaded backpack");
}
else
{
    UO.Print("Gold serial: " + gold);
    UO.Info(gold);
}

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

2. Cerca ricorsivamente un oggetto nelle borse dello zaino caricate - funzione script

Parametri e flusso di esecuzione:

1: wantedType contiene graphic 0x0EED.
2: -1 rimuove il filtro colorato.
3: "backpack" seleziona il contenitore root.
4: -1 utilizza la corrente FindDistance.
5: ricorsivo=1 abilita l'attraversamento dei sottocontenitori; questa è una forma a cinque argomenti. Il contenuto di un bagaglio chiuso che il server non ha ancora inviato non viene caricato in questo modo.
AddObject salva il serial trovato con il nome find_gold solo dopo aver controllato il risultato.

return  RunScenario();
 object? RunScenario()
{
    var wantedType = 0x0EED;
    var recursive = 1;
    var found = UO.FindType(wantedType, -1, "backpack", -1, recursive);
    if (Truth(found != ""))
    {
        UO.AddObject("found_gold", found);
        UO.Print("Saved object: " + found);
    }
    else
    {
        UO.Print("No matching item in loaded containers");
    }

    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. Trova il personaggio più vicino con una delle due reputazioni: classe dello scenario

Parametri e flusso di esecuzione:

1: body=-1 consente qualsiasi body.
2: color=-1 consente qualsiasi colore.
3: "ground" significa oggetti del mondo caricati.
4: raggio=10 limita la distanza a dieci celle.
5: reputazione="3|6" - attaccabile o assassino. È notorietà, non ricorsiva.
6: neighbor=1 ti chiede di scegliere quello più vicino. Il filtro reputazione esclude gli articoli. L'esempio mostra solo informazioni e non attacca il bersaglio.

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 body = -1;
        var radius = 10;
        var reputation = "3|6";
        var nearest = 1;
        var found = UO.FindType(body, -1, "ground", radius, reputation, nearest);
        if (Truth(found != ""))
        {
            UO.Print("Matching mobile: " + found);
            UO.Info(found);
        }
        else
        {
            UO.Print("No matching mobile within the radius");
        }

        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. Tutti i quattordici parametri: un mob visibile dal vivo con un nome adatto - script diretto

Parametri e flusso di esecuzione:

1 body=-1 e 2 hue=-1 non limitano il tipo e il colore.
3 scope="ground" - cerca nel mondo; 4 raggio=5 - non più di cinque celle.
5 reputazione=-1 consente qualsiasi notorietà; 6 più vicino=1 seleziona quello più vicino.
7 maxZ=16 consente dislivelli assoluti fino a 16 unità.
8 mobileOnly=1 esclude gli articoli; 9 itemOnly=0 non proibisce i mob.
10 includeIgnored=0 mantiene l'effetto di IgnoreList.
11 includeSelf=0 esclude il tuo personaggio.
12 aliveOnly=1 e 13 visibleOnly=1 lasciano in vita i candidati visibili.
14names="orc|troll" richiede la sottostringa orc o troll in un nome già noto al client. Tutti i filtri devono essere eseguiti contemporaneamente.

var body = -1;
var hue = -1;
var scope = "ground";
var radius = 5;
var reputation = -1;
var nearest = 1;
var maxZ = 16;
var mobileOnly = 1;
var itemOnly = 0;
var includeIgnored = 0;
var includeSelf = 0;
var aliveOnly = 1;
var visibleOnly = 1;
var names = "orc|troll";
var found = UO.FindType(body, hue, scope, radius, reputation, nearest, maxZ, mobileOnly, itemOnly, includeIgnored, includeSelf, aliveOnly, visibleOnly, names);
if (Truth(found == ""))
{
    UO.Print("No loaded mobile satisfies every filter");
}
else
{
    UO.Print("Selected serial: " + found);
}

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

5. Forma abbreviata di ricerca nello zaino: funzione script

Parametri e flusso di esecuzione:

1 wantedType=0x0EED è oro.
2 "my" è una stringa speciale con forma a due argomenti: seleziona uno zaino, include la ricorsione e qualsiasi colore. Qui il secondo argomento non è hue.
Per il livello più alto, invece di "my", passa "backpack"; per il mondo - "ground". Il numero in seconda posizione, invece, sarà un filtro colorato.

return  RunScenario();
 object? RunScenario()
{
    var wantedType = 0x0EED;
    var found = UO.FindType(wantedType, "my");
    if (Truth(found != ""))
    {
        UO.Print("Found in backpack or a loaded subcontainer: " + found);
    }
    else
    {
        UO.Print("Nothing found");
    }

    return null;
}

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

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

Parametri: type (Any)

Risultato: string / String.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.FindType.
InjectionScript.Runtime.InjectionApiUO.FindType: FindType(ResolveType(type)).
InjectionScript.Runtime.InjectionApiUO.ResolveType: ResolveType(type).

Codice interno di implementazione; non è uno script autonomo.

public string FindType(InjectionValue type)

            => FindType(ResolveType(type));

`UO.FindType(type, color)` — `UO.FindType(Any,Any)`

Parametri: type (Any), color (Any)

Risultato: string / String.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.FindType.
InjectionScript.Runtime.InjectionApiUO.FindType: FindType(ResolveType(type), -1, ConvertContainer(color), -1, color.String.Equals("my", StringComparison.OrdinalIgnoreCase)).
InjectionScript.Runtime.InjectionApiUO.ResolveType: ResolveType(type).
InjectionScript.Runtime.InjectionApiUO.ConvertContainer: ConvertContainer(color).
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(color).

Codice interno di implementazione; non è uno script autonomo.

public string FindType(InjectionValue type, InjectionValue color)

        {

            if (color.Kind == InjectionValueKind.String

                && (color.String.Equals("ground", StringComparison.OrdinalIgnoreCase)

                    || color.String.Equals("backpack", StringComparison.OrdinalIgnoreCase)

                    || color.String.Equals("my", StringComparison.OrdinalIgnoreCase)))

            {

                return FindType(ResolveType(type), -1, ConvertContainer(color), -1, color.String.Equals("my", StringComparison.OrdinalIgnoreCase));

            }



            return FindType(ResolveType(type), NumberConversions.ToInt(color), -1, -1, false);

        }

`UO.FindType(type, color, container)` — `UO.FindType(Any,Any,Any)`

Parametri: type (Any), color (Any), container (Any)

Risultato: string / String.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.FindType.
InjectionScript.Runtime.InjectionApiUO.FindType: FindType(type, color, container, new InjectionValue(-1)).

Codice interno di implementazione; non è uno script autonomo.

public string FindType(InjectionValue type, InjectionValue color, InjectionValue container)

            => FindType(type, color, container, new InjectionValue(-1));

`UO.FindType(type, color, container, range)` — `UO.FindType(Any,Any,Any,Any)`

Parametri: type (Any), color (Any), container (Any), range (Any)

Risultato: string / String.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.FindType.
InjectionScript.Runtime.InjectionApiUO.FindType: FindType(ResolveType(type), NumberConversions.ToInt(color), ConvertContainer(container), NumberConversions.ToInt(range), true).
InjectionScript.Runtime.InjectionApiUO.ResolveType: ResolveType(type).
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(color).
InjectionScript.Runtime.InjectionApiUO.ConvertContainer: ConvertContainer(container).

Codice interno di implementazione; non è uno script autonomo.

public string FindType(InjectionValue type, InjectionValue color, InjectionValue container, InjectionValue range)

        {

            if (container.Kind == InjectionValueKind.String && container.String.Equals("my", StringComparison.OrdinalIgnoreCase))

                return FindType(ResolveType(type), NumberConversions.ToInt(color), ConvertContainer(container), NumberConversions.ToInt(range), true);

            else

                return FindType(ResolveType(type), NumberConversions.ToInt(color), ConvertContainer(container), NumberConversions.ToInt(range), false);

        }

`UO.FindType(type, color, container, distance, recursive)` — `UO.FindType(Any,Any,Any,Any,Any)`

Parametri: type (Any), color (Any), container (Any), distance (Any), recursive (Any)

Risultato: string / String.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Register [FindType].
InjectionScript.Runtime.InjectionApiUO.FindType: FindType(values[0], values[1], values[2], values[3], values[4]).

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(FindType(values[0], values[1], values[2], values[3], values[4]))

`UO.FindType(type, color, container, distance, notoriety, nearest)` — `UO.FindType(Any,Any,Any,Any,Any,Any)`

Parametri: type (Any), color (Any), container (Any), distance (Any), notoriety (Any), nearest (Any)

Risultato: string / String.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Register [FindType].
InjectionScript.Runtime.InjectionApiUO.CompactFindType: CompactFindType(values[0], values[1], values[2], values[3], values[4], values[5]).

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 =>

                CompactFindType(values[0], values[1], values[2], values[3], values[4], values[5])

`UO.FindType(type, color, container, distance, notoriety, nearest, maxZ)` — `UO.FindType(Any,Any,Any,Any,Any,Any,Any)`

Parametri: type (Any), color (Any), container (Any), distance (Any), notoriety (Any), nearest (Any), maxZ (Any)

Risultato: string / String.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Register [FindType].
InjectionScript.Runtime.InjectionApiUO.CompactFindTypeExtended: CompactFindTypeExtended(values).

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 => CompactFindTypeExtended(values)

`UO.FindType(type, color, container, distance, notoriety, nearest, maxZ, mobileOnly)` — `UO.FindType(Any,Any,Any,Any,Any,Any,Any,Any)`

Parametri: type (Any), color (Any), container (Any), distance (Any), notoriety (Any), nearest (Any), maxZ (Any), mobileOnly (Any)

Risultato: string / String.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Register [FindType].
InjectionScript.Runtime.InjectionApiUO.CompactFindTypeExtended: CompactFindTypeExtended(values).

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 => CompactFindTypeExtended(values)

`UO.FindType(type, color, container, distance, notoriety, nearest, maxZ, mobileOnly, itemOnly)` — `UO.FindType(Any,Any,Any,Any,Any,Any,Any,Any,Any)`

Parametri: type (Any), color (Any), container (Any), distance (Any), notoriety (Any), nearest (Any), maxZ (Any), mobileOnly (Any), itemOnly (Any)

Risultato: string / String.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Register [FindType].
InjectionScript.Runtime.InjectionApiUO.CompactFindTypeExtended: CompactFindTypeExtended(values).

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 => CompactFindTypeExtended(values)

`UO.FindType(type, color, container, distance, notoriety, nearest, maxZ, mobileOnly, itemOnly, includeIgnored)` — `UO.FindType(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)`

Parametri: type (Any), color (Any), container (Any), distance (Any), notoriety (Any), nearest (Any), maxZ (Any), mobileOnly (Any), itemOnly (Any), includeIgnored (Any)

Risultato: string / String.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Register [FindType].
InjectionScript.Runtime.InjectionApiUO.CompactFindTypeExtended: CompactFindTypeExtended(values).

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 => CompactFindTypeExtended(values)

`UO.FindType(type, color, container, distance, notoriety, nearest, maxZ, mobileOnly, itemOnly, includeIgnored, includeSelf)` — `UO.FindType(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)`

Parametri: type (Any), color (Any), container (Any), distance (Any), notoriety (Any), nearest (Any), maxZ (Any), mobileOnly (Any), itemOnly (Any), includeIgnored (Any), includeSelf (Any)

Risultato: string / String.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Register [FindType].
InjectionScript.Runtime.InjectionApiUO.CompactFindTypeExtended: CompactFindTypeExtended(values).

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 => CompactFindTypeExtended(values)

`UO.FindType(type, color, container, distance, notoriety, nearest, maxZ, mobileOnly, itemOnly, includeIgnored, includeSelf, aliveOnly)` — `UO.FindType(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)`

Risultato: string / String.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Register [FindType].
InjectionScript.Runtime.InjectionApiUO.CompactFindTypeExtended: CompactFindTypeExtended(values).

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 => CompactFindTypeExtended(values)

`UO.FindType(type, color, container, distance, notoriety, nearest, maxZ, mobileOnly, itemOnly, includeIgnored, includeSelf, aliveOnly, visibleOnly)` — `UO.FindType(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)`

Risultato: string / String.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Register [FindType].
InjectionScript.Runtime.InjectionApiUO.CompactFindTypeExtended: CompactFindTypeExtended(values).

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 => CompactFindTypeExtended(values)

`UO.FindType(type, color, container, distance, notoriety, nearest, maxZ, mobileOnly, itemOnly, includeIgnored, includeSelf, aliveOnly, visibleOnly, nameMask)` — `UO.FindType(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)`

Risultato: string / String.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Register [FindType].
InjectionScript.Runtime.InjectionApiUO.CompactFindTypeExtended: CompactFindTypeExtended(values).

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 => CompactFindTypeExtended(values)

UO.FindTypeEx

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

Firme C#

int UO.FindTypeEx(object? objType, object? color, object? container, object? inSub);

Cerca un grafico e un colore in un contenitore o per terra e restituisce quello trovato ID.

Parametri

objType - Grafico/body, non elemento serial. 0..65534 - grafica specifica; -1 o 0xFFFF - qualsiasi. Anche altri negativi int in questo client rimuovono il filtro.
color — Tonalità, non il numero di elementi. 0 - oggetto non verniciato; -1 o 0xFFFF - qualsiasi hue. Anche gli altri negativi int rimuovono il filtro colorato.
container - Terra: UO.Ground(), 0, -1, 0xFFFFFFFF o corda ground. Backpack: string backpack or its serial. Sono accettati i valori decimali/esadecimali serial e il nome AddObject. my seleziona l'intero inventario del suo personaggio, compreso l'equipaggiamento e le borse annesse. Un nome sconosciuto causa un errore di script. Controlla il serial risultante: l'esplicito 0 seleziona il terreno. I nomi ground/backpack sono più chiari delle designazioni numeriche, che differiscono tra le famiglie di comandi.
inSub - Obbligatorio true/false (1/0). false - contenuto diretto di uno specifico contenitore; true – caricati anche sacchi annidati. Per la terra la ricorsione non cambia nulla. my seleziona già tutto l'inventario del personaggio.

Valore restituito

int: serial prima corrispondenza nell'ordine di attraversamento locale; 0 se non ci sono corrispondenze. Non graphic, conteggio, array o bool. Controlla il risultato != 0, non il risultato == true o il risultato == 1. Una pila è considerata un oggetto; Mobile: un oggetto e un'unità. L'ordine non implica vicinanza e non è garantito tra le ricerche.

Comportamento

Sono necessari tutti e quattro gli argomenti posizionali. Non sono presenti argomenti facoltativi.
Earth utilizza FindDistance e FindVertical di questo script, esclude self e include l'oggetto e il cellulare appropriati. La ricerca all'interno di un contenitore specifico non applica questi limiti di distanza/altezza. In entrambi i casi sono esclusi Ignore e gli oggetti distrutti.
Prima del bypass, FindItem, FindCount, FindFullQuantity e GetFoundItems vengono cancellati. Si riferiscono quindi a questa ricerca; la ricerca vuota lascia zeri e un array vuoto. FindFullQuantity riassume il numero massimo di articoli (1, Importo) e per 1 per dispositivi mobili. FindQuantity legge la quantità corrente FindItem. Salva GetFoundItems se, dopo un'altra ricerca, la lista precedente è ancora necessaria.
Il ponte attraversa gli elementi caricati una volta, quindi Mobile se è selezionata la terra. Il tipo, il colore e almeno un contenitore devono corrispondere. Un oggetto viene conteggiato una volta, anche se soddisfa diverse condizioni. Non esiste una traversata completa e ripetuta del mondo per ciascuna combinazione.
Vengono letti solo i dati ricevuti dal client. I contenitori non si aprono, le celle della mappa non si caricano, non avviene alcun trasferimento. Un risultato vuoto non prova che il forziere sul server sia vuoto. Se è necessario un collegamento attivo, seleziona Connected: la ricerca stessa legge lo stato locale.
La prima corrispondenza locale viene archiviata qui; un nome sconosciuto non sposta la ricerca sullo zaino. Ground accetta anche 0; il tuo FindDistance predefinito 18, massimo 255. Queste sono le caratteristiche di questo cliente.

Script C# autonomi

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.FindTypeEx(0x0EED, -1, "backpack", false);
UO.Print("FindTypeEx: " + Convert.ToString(result));

1. Contenuto diretto dello zaino - sceneggiatura diretta

Parametri e flusso di esecuzione:

0x0EED - oro, -1 - qualsiasi hue; backpack/false esclude i sacchetti annidati. Le tre righe restituiscono il primo ID in esadecimale senza 0x, il numero di oggetti e la somma di quelli. Due pile di 20 e 50: oggetti 2, unità 70.

var item = UO.FindTypeEx(0x0EED, -1, "backpack", false);
UO.Print(Hex(item));
UO.Print(Convert.ToString(UO.FindCount()));
UO.Print(Convert.ToString(UO.FindFullQuantity()));

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

2. Funzione di ricerca sul terreno a tempo pieno - Funzione script

Parametri e flusso di esecuzione:

raggio=5 e altezza=10 operano all'interno di FindGoldNearSelf. Infine ripristina entrambi i limiti anche in caso di reso o errore. La funzione restituisce serial oro o 0; Controlli principali != 0 prima dell'output.

return  RunScenario();
 object? RunScenario()
{
    var item = FindGoldNearSelf(5, 10);
    if (Truth(item != 0))
    {
        UO.Print(Hex(item));
    }
    else
    {
        UO.Print("Empty");
    }

    return null;
}

dynamic FindGoldNearSelf(dynamic radius, dynamic height)
{
    var oldDistance = UO.FindDistance();
    var oldVertical = UO.FindVertical();
    try
    {
        UO.FindDistance(radius);
        UO.FindVertical(height);
        return UO.FindTypeEx(0x0EED, -1, UO.Ground(), false);
    }
    finally
    {
        UO.FindDistance(oldDistance);
        UO.FindVertical(oldVertical);
    }
}

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

3. Nome del contenitore e contenitori nidificati: classe di script

Parametri e flusso di esecuzione:

GetSerial consente backpack; il controllo dello zero impedisce la selezione casuale del terreno. AddObject salva ID come search_bag. true include sacchetti annidati. GetFoundItems memorizza un array separato; IsObjectExists ricontrolla ogni ID.

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

     public object? RunScenario()
    {
        var bag = UO.GetSerial("backpack");
        if (Truth(bag != "0x00000000"))
        {
            UO.AddObject("search_bag", bag);
            UO.FindTypeEx(0x0EED, -1, "search_bag", true);
            var items = UO.GetFoundItems();
            foreach (var item in items)
            {
                if (Truth(UO.IsObjectExists(item)))
                {
                    UO.Print(Hex(item));
                }
            }
        }

        return null;
    }

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

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.FindTypeEx(objType, color, container, inSub)` — `UO.FindTypeEx(Any,Any,Any,Any)`

Parametri: objType (Any), color (Any), container (Any), inSub (Any)

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.FindType: bridge.FindType(ResolveType(arguments[0]), Arg(1), StealthContainer(2), -1, Arg(3) != 0).
InjectionScript.Runtime.InjectionApiUO.ResolveType: ResolveType(arguments[0]).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(1).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::StealthContainer: StealthContainer(2).

Codice interno di implementazione; non è uno script autonomo.

case "findtypeex": return new InjectionValue(bridge.FindType(ResolveType(arguments[0]), Arg(1), StealthContainer(2), -1, Arg(3) != 0));

UO.FindTypesArrayEx

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

Firme C#

int UO.FindTypesArrayEx(object? objTypes, object? colors, object? containers, object? inSub);

In un attraversamento cerca grafici, colori e contenitori diversi e restituisce quello trovato ID. L'elenco completo viene letto tramite GetFoundItems.

Parametri

objTypes - Grafico/body, non elemento serial. 0..65534 - grafica specifica; -1 o 0xFFFF - qualsiasi. Anche altri negativi int in questo client rimuovono il filtro.
colors — Tonalità, non il numero di elementi. 0 - oggetto non verniciato; -1 o 0xFFFF - qualsiasi hue. Anche gli altri negativi int rimuovono il filtro colorato.
containers - Terra: UO.Ground(), 0, -1, 0xFFFFFFFF o corda ground. Backpack: string backpack or its serial. Sono accettati i valori decimali/esadecimali serial e il nome AddObject. my seleziona l'intero inventario del suo personaggio, compreso l'equipaggiamento e le borse annesse. Un nome sconosciuto causa un errore di script. Controlla il serial risultante: l'esplicito 0 seleziona il terreno. I nomi ground/backpack sono più chiari delle designazioni numeriche, che differiscono tra le famiglie di comandi.
inSub - Obbligatorio true/false (1/0). false - contenuto diretto di uno specifico contenitore; true – caricati anche sacchi annidati. Per la terra la ricorsione non cambia nulla. my seleziona già tutto l'inventario del personaggio.

Valore restituito

Comportamento

Viene passato l'array; un singolo valore viene anche trattato come un array di un elemento. dichiarando i valori della variabile[1] si creano gli indici 0 e 1: riempili ciascuno. Tipi e colori sono opzioni indipendenti, non coppie per indice. Una maschera "qualsiasi" in qualsiasi posizione o un array vuoto di tipi/colori rimuove questo filtro. Una serie vuota di contenitori seleziona l'inventario del personaggio. Le ripetizioni e le intersezioni dei contenitori non duplicano ID.
Sono necessari tutti e quattro gli argomenti posizionali. Non sono presenti argomenti facoltativi.
Earth utilizza FindDistance e FindVertical di questo script, esclude self e include l'oggetto e il cellulare appropriati. La ricerca all'interno di un contenitore specifico non applica questi limiti di distanza/altezza. In entrambi i casi sono esclusi Ignore e gli oggetti distrutti.
Prima del bypass, FindItem, FindCount, FindFullQuantity e GetFoundItems vengono cancellati. Si riferiscono quindi a questa ricerca; la ricerca vuota lascia zeri e un array vuoto. FindFullQuantity riassume il numero massimo di articoli (1, Importo) e per 1 per dispositivi mobili. FindQuantity legge la quantità corrente FindItem. Salva GetFoundItems se, dopo un'altra ricerca, la lista precedente è ancora necessaria.
Il ponte attraversa gli elementi caricati una volta, quindi Mobile se è selezionata la terra. Il tipo, il colore e almeno un contenitore devono corrispondere. Un oggetto viene conteggiato una volta, anche se soddisfa diverse condizioni. Non esiste una traversata completa e ripetuta del mondo per ciascuna combinazione.
Vengono letti solo i dati ricevuti dal client. I contenitori non si aprono, le celle della mappa non si caricano, non avviene alcun trasferimento. Un risultato vuoto non prova che il forziere sul server sia vuoto. Se è necessario un collegamento attivo, seleziona Connected: la ricerca stessa legge lo stato locale.
La prima corrispondenza locale viene archiviata qui; un nome sconosciuto non sposta la ricerca sullo zaino. Ground accetta anche 0; il tuo FindDistance predefinito 18, massimo 255. Queste sono le caratteristiche di questo cliente.

Script C# autonomi

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.FindTypesArrayEx(new[] { 0x0EED }, new[] { -1 }, new[] { "backpack" }, false);
UO.Print("FindTypesArrayEx: " + Convert.ToString(result));

1. Due grafici a terra: sceneggiatura diretta

Parametri e flusso di esecuzione:

i tipi contengono oro 0x0EED e perla nera 0x0F7A; un colore=-1 - qualsiasi hue, uno Ground - terra. false non cambia nulla sulla terra. Si applicano i limiti di ricerca attuali. ID, vengono emessi il numero di oggetti e la somma delle unità.

dynamic[] types = new dynamic[checked((int)(1) + 1)];
types[0] = 0x0EED;
types[1] = 0x0F7A;
dynamic[] colors = new dynamic[checked((int)(0) + 1)];
colors[0] = -1;
dynamic[] containers = new dynamic[checked((int)(0) + 1)];
containers[0] = UO.Ground();
var first = UO.FindTypesArrayEx(types, colors, containers, false);
UO.Print(Hex(first));
UO.Print(Convert.ToString(UO.FindCount()));
UO.Print(Convert.ToString(UO.FindFullQuantity()));

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

2. Oro nello zaino e a terra - funzione script

Parametri e flusso di esecuzione:

tipi: solo oro; colori: qualsiasi hue. Container - backpack e terra; true include sacchetti annidati. Vengono emessi oggetti/pile e unità da entrambe le aree, ciascun oggetto viene conteggiato una volta.

return  RunScenario();
 object? RunScenario()
{
    dynamic[] types = new dynamic[checked((int)(0) + 1)];
    types[0] = 0x0EED;
    dynamic[] colors = new dynamic[checked((int)(0) + 1)];
    colors[0] = -1;
    dynamic[] containers = new dynamic[checked((int)(1) + 1)];
    containers[0] = "backpack";
    containers[1] = UO.Ground();
    UO.FindTypesArrayEx(types, colors, containers, true);
    UO.Print(Convert.ToString(UO.FindCount()));
    UO.Print(Convert.ToString(UO.FindFullQuantity()));
    return null;
}

3. Funzione completa con elenco dei risultati - Classe di script

Parametri e flusso di esecuzione:

SearchTypesIn(contenitore,firstType,secondType) restituisce un Array, mentre il comando integrato restituisce un singolo int ID. La funzione completa sopra riempie gli array, cerca ricorsivamente e copia immediatamente GetFoundItems. Main controlla ogni ID memorizzato e lo emette.

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

     public object? RunScenario()
    {
        var items = SearchTypesIn("backpack", 0x0EED, 0x0F7A);
        foreach (var item in items)
        {
            if (Truth(UO.IsObjectExists(item)))
            {
                UO.Print(Hex(item));
            }
        }

        return null;
    }

    dynamic SearchTypesIn(dynamic container, dynamic firstType, dynamic secondType)
    {
        dynamic[] types = new dynamic[checked((int)(1) + 1)];
        types[0] = firstType;
        types[1] = secondType;
        dynamic[] colors = new dynamic[checked((int)(0) + 1)];
        colors[0] = -1;
        dynamic[] containers = new dynamic[checked((int)(0) + 1)];
        containers[0] = container;
        UO.FindTypesArrayEx(types, colors, containers, true);
        return UO.GetFoundItems();
    }

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

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.FindTypesArrayEx(objTypes, colors, containers, inSub)` — `UO.FindTypesArrayEx(Any,Any,Any,Any)`

Parametri: objTypes (Any), colors (Any), containers (Any), inSub (Any)

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.FindTypes: bridge.FindTypes(arguments[0].Kind == InjectionValueKind.Array ? arguments[0].Array.Select(ResolveType).ToArray() : new[] { ResolveType(arguments[0]) }, ArrayArg(1), searchContainers.Select(ConvertClientSearchContainer).ToArray(), Arg(3) != 0).
InjectionScript.Runtime.InjectionApiUO.ResolveType: ResolveType(arguments[0]).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::ArrayArg: ArrayArg(1).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(3).

Codice interno di implementazione; non è uno script autonomo.

case "findtypesarrayex":

                    InjectionValue[] searchContainers = arguments[2].Kind == InjectionValueKind.Array

                        ? arguments[2].Array : new[] { arguments[2] };

                    return new InjectionValue(bridge.FindTypes(arguments[0].Kind == InjectionValueKind.Array

                        ? arguments[0].Array.Select(ResolveType).ToArray() : new[] { ResolveType(arguments[0]) }, ArrayArg(1),

                        searchContainers.Select(ConvertClientSearchContainer).ToArray(), Arg(3) != 0));

UO.FindVertical

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

Firme C#

int UO.FindVertical();
void UO.FindVertical(object? value);

Legge o modifica il dislivello consentito nella ricerca predefinita.

Parametri

value — Opzionale int. Senza discussione: lettura; valore: impostazione. Il valore è limitato all'intervallo 0..120; il negativo diventa 0 anziché illimitato. Nel nuovo runtime: 2; lo stato ripristinato potrebbe contenere un valore diverso. Il numero frazionario viene troncato a zero; sono accettabili anche stringhe numeriche double/0x. Utilizzare int per evitare la conversione implicita.

Valore restituito

Senza argomenti: int - limite corrente (differenza nelle unità mondiali Z), non trovato ID, numero di oggetti o bool. 0 significa limite zero, non fallimento. Con valore: void - nessun valore; questa non è true/false o la vecchia impostazione. Una volta installato, leggi FindVertical() per scoprire il valore memorizzato.

Comportamento

Altezza: addominali(object.Z - player.Z), in entrambe le direzioni, compreso il bordo. Per 0 è adatto solo lo stesso Z. Questo non è il numero del piano o il numero di celle orizzontali.
L'impostazione viene memorizzata nel runtime dello script corrente; le sue procedure utilizzano un singolo valore. I runtime indipendenti hanno impostazioni separate. La lettura e la scrittura non attivano una ricerca, cancellano FindItem/FindCount/GetFoundItems, inviano un pacchetto, spostano un personaggio o caricano oggetti distanti.
FindTypeEx e FindTypesArrayEx utilizzano questi limiti durante la ricerca a terra, ma non all'interno del contenitore. I restanti filtri sono type, hue, Ignore e la presenza di un oggetto caricato. FindAtCoord ignores both limits. Nei comandi estesi, la distanza esplicita/maxZ può sovrascrivere le impostazioni; -1 in tali parametri significa prendere l'impostazione, invece di impostare l'impostazione stessa su -1. FindList filtra anche Z durante la ricerca dei contenitori; l'eccezione del contenitore specificato non si applica ad esso.
Prima di effettuare una ricerca temporanea, salvare il valore e ripristinarlo in Finalmente. L'installazione non viene annullata automaticamente. Finalmente funziona con il completamento normale e con un errore di script rilevato; L'arresto di emergenza non può essere utilizzato come meccanismo di pulizia.

Script C# autonomi

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

1. Lettura, impostazione e limite di intervallo - Script diretto

Parametri e flusso di esecuzione:

precedente salva l'impostazione attuale. valore:=10 imposta il limite normale; 1000 mostra il limite a 120. Print legge il risultato come una chiamata separata senza argomenti. Finalmente ripristina il precedente.

var previous = UO.FindVertical();
try
{
    UO.FindVertical(10);
    UO.Print(Convert.ToString(UO.FindVertical()));
    UO.FindVertical(1000);
    UO.Print(Convert.ToString(UO.FindVertical()));
}
finally
{
    UO.FindVertical(previous);
}

2. Ricerca temporanea sul terreno - Funzione script

Parametri e flusso di esecuzione:

precedente salva l'impostazione del codice chiamante. 10 cambia solo FindVertical; il secondo limite rimane lo stesso. 0x0EED - grafica dorata, -1 - qualsiasi hue, Contenitore=-1 - mondo, false - senza ricorsione del contenitore. id - uno serial; != 0 verifica la disponibilità. FindCount conta interi oggetti/pile. Infine ripristina l'impostazione, non l'elenco dei risultati.

return  RunScenario();
 object? RunScenario()
{
    var previous = UO.FindVertical();
    try
    {
        UO.FindVertical(10);
        var id = UO.FindTypeEx(0x0EED, -1, -1, false);
        if (Truth(id != 0))
        {
            UO.Print(Hex(id) + ":" + Convert.ToString(UO.FindCount()));
        }
        else
        {
            UO.Print("0");
        }
    }
    finally
    {
        UO.FindVertical(previous);
    }

    return null;
}

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

3. Funzione completa CountGroundInRange - classe di script

Parametri e flusso di esecuzione:

CountGroundInRange(graphic, raggio, altezza) memorizza entrambi i limiti, imposta raggio=5 e altezza=10, cerca graphic=0x0EED e restituisce FindCount(). Una pila è considerata un oggetto. La funzione completa viene fornita dopo Main. Ripristina infine entrambi i limiti anche in uscita tramite ritorno; il risultato della ricerca rimane disponibile.

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 count = CountGroundInRange(0x0EED, 5, 10);
        UO.Print(Convert.ToString(count));
        return null;
    }

    dynamic CountGroundInRange(dynamic graphic, dynamic radius, dynamic height)
    {
        var oldDistance = UO.FindDistance();
        var oldVertical = UO.FindVertical();
        try
        {
            UO.FindDistance(radius);
            UO.FindVertical(height);
            UO.FindTypeEx(graphic, -1, -1, false);
            return UO.FindCount();
        }
        finally
        {
            UO.FindDistance(oldDistance);
            UO.FindVertical(oldVertical);
        }
    }
}

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

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.SetFindVertical: bridge.SetFindVertical(Arg(0)).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetFindVertical: bridge.GetFindVertical().

Codice interno di implementazione; non è uno script autonomo.

case "findvertical":

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

                    return new InjectionValue(bridge.GetFindVertical());

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

Parametri: value (Any)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.SetFindVertical: bridge.SetFindVertical(Arg(0)).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetFindVertical: bridge.GetFindVertical().

Codice interno di implementazione; non è uno script autonomo.

case "findvertical":

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

                    return new InjectionValue(bridge.GetFindVertical());

UO.GetFindedList

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

Firme C#

dynamic UO.GetFindedList(object? userList);

Crea una copia della lista ID dell'ultima ricerca normale.

Parametri

userList — Argomento di compatibilità richiesto. Nell'implementazione corrente non viene popolato né modificato: l'elenco viene restituito come risultato del comando. Puoi superare 0. Per una forma senza argomenti, utilizzare GetFoundItems.

Valore restituito

Array è un array separato serial/ID nell'ultimo ordine di ricerca. Un Array vuoto se non ci sono corrispondenze. Non contiene graphic, hue o Importo. La modifica dell'array restituito non modifica l'elenco di ricerca salvato.

Comportamento

Vengono letti i dati già scaricati dal client. Il comando non apre il contenitore, non sposta elementi né scarica oggetti dall'intero server.
Array - array con indici a partire da 0. Salvalo in var, controlla ArrayLength prima di accedere. Gli elementi potrebbero scomparire dal mondo dopo aver scattato una foto: controlla Exists(serial) prima di agire.
I dati appartengono all'ultima ricerca normale di questo script. FindType con argomenti 1–5, FindTypeEx, Count/CountEx/CountGround sostituiscono i risultati. Non sono necessari comandi avanzati di caratteri filtrati per modificare questa istantanea.
Una nuova ricerca senza corrispondenze cancella FindItem, FindCount e FindFullQuantity e cancella GetFoundItems. La sola lettura di un risultato non attiva una nuova ricerca.

Script C# autonomi

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.

UO.FindType(0x0EED, -1, "backpack");
object? result = UO.GetFindedList(0);
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

1. Ottieni la dimensione dell'elenco: script diretto

Parametri e flusso di esecuzione:

Il solito FindType per l'oro nello zaino è già pronto. UserList=0 non è un parametro di uscita.
Lunghezza - numero di record/ID. Questo non è l'importo dell'importo in pile. L'elenco vuoto dà 0.

var found = UO.FindType(0x0EED, -1, "backpack");
var items = UO.GetFindedList(0);
UO.Print(Convert.ToString(ArrayLength(items)));

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

2. Attraversa tutto trovato ID - funzione script

Parametri e flusso di esecuzione:

Il solito FindType per l'oro nello zaino è già pronto. UserList=0 non è un parametro di uscita.
elementi[i] — numerico serial. Hex viene utilizzato solo per l'output. Il ciclo non accede all'ultimo indice.

return  RunScenario();
 object? RunScenario()
{
    var found = UO.FindType(0x0EED, -1, "backpack");
    var items = UO.GetFindedList(0);
    var i = 0;
    while (Truth(i < ArrayLength(items)))
    {
        UO.Print("0x" + Hex(items[i]));
        i = i + 1;
    }

    return null;
}

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

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

Parametri e flusso di esecuzione:

Il solito FindType per l'oro nello zaino è già pronto. UserList=0 non è un parametro di uscita.
Vengono controllate due cose diverse: il record nell'istantanea e l'esistenza dell'oggetto adesso. L'ordine senza una cernita esplicita non significa vicinanza.

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

     public object? RunScenario()
    {
        var found = UO.FindType(0x0EED, -1, "backpack");
        var items = UO.GetFindedList(0);
        if (Truth(ArrayLength(items) > 0))
        {
            var first = items[0];
            if (Truth(UO.Exists(first)))
            {
                UO.Print(UO.GetName(first));
            }
        }
        else
        {
            UO.Print("Empty list");
        }

        return null;
    }

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

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.GetFindedList(userList)` — `UO.GetFindedList(Any)`

Parametri: userList (Any)

Risultato: dynamic / Any.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "getfindedlist":

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

UO.GetFoundItems

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

Firme C#

dynamic UO.GetFoundItems();

Crea una copia della lista ID dell'ultima ricerca normale.

Parametri

Non ci sono parametri.

Valore restituito

Comportamento

Vengono letti i dati già scaricati dal client. Il comando non apre il contenitore, non sposta elementi né scarica oggetti dall'intero server.
Array - array con indici a partire da 0. Salvalo in var, controlla ArrayLength prima di accedere. Gli elementi potrebbero scomparire dal mondo dopo aver scattato una foto: controlla Exists(serial) prima di agire.
I dati appartengono all'ultima ricerca normale di questo script. FindType con argomenti 1–5, FindTypeEx, Count/CountEx/CountGround sostituiscono i risultati. Non sono necessari comandi avanzati di caratteri filtrati per modificare questa istantanea.
Una nuova ricerca senza corrispondenze cancella FindItem, FindCount e FindFullQuantity e cancella GetFoundItems. La sola lettura di un risultato non attiva una nuova ricerca.

Script C# autonomi

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.

UO.FindType(0x0EED, -1, "backpack");
object? result = UO.GetFoundItems();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

1. Ottieni la dimensione dell'elenco: script diretto

Parametri e flusso di esecuzione:

Il solito FindType per l'oro nello zaino è già pronto. Non ci sono parametri.
Lunghezza - numero di record/ID. Questo non è l'importo dell'importo in pile. L'elenco vuoto dà 0.

var found = UO.FindType(0x0EED, -1, "backpack");
var items = UO.GetFoundItems();
UO.Print(Convert.ToString(ArrayLength(items)));

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

2. Attraversa tutto trovato ID - funzione script

Parametri e flusso di esecuzione:

Il solito FindType per l'oro nello zaino è già pronto. Non ci sono parametri.
elementi[i] — numerico serial. Hex viene utilizzato solo per l'output. Il ciclo non accede all'ultimo indice.

return  RunScenario();
 object? RunScenario()
{
    var found = UO.FindType(0x0EED, -1, "backpack");
    var items = UO.GetFoundItems();
    var i = 0;
    while (Truth(i < ArrayLength(items)))
    {
        UO.Print("0x" + Hex(items[i]));
        i = i + 1;
    }

    return null;
}

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

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

Parametri e flusso di esecuzione:

Il solito FindType per l'oro nello zaino è già pronto. Non ci sono parametri.
Vengono controllate due cose diverse: il record nell'istantanea e l'esistenza dell'oggetto adesso. L'ordine senza una cernita esplicita non significa vicinanza.

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

     public object? RunScenario()
    {
        var found = UO.FindType(0x0EED, -1, "backpack");
        var items = UO.GetFoundItems();
        if (Truth(ArrayLength(items) > 0))
        {
            var first = items[0];
            if (Truth(UO.Exists(first)))
            {
                UO.Print(UO.GetName(first));
            }
        }
        else
        {
            UO.Print("Empty list");
        }

        return null;
    }

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

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

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "getfounditems":

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

UO.GetIgnoreList

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

Firme C#

dynamic UO.GetIgnoreList();

Mostra lo specifico ID aggiunto al filtro serial tramite Ignore. Aiuta a verificare quali elementi sono già stati elaborati e sono esclusi dalla ricerca. Le regole denominate type/hue da AddIgnoreList non sono incluse in questo array.

Parametri

Non ci sono parametri.

Valore restituito

Array - serial dall'elenco Ignore in ordine crescente di ID numerico. Array vuoto quando l'elenco è vuoto. ID potrebbe non esistere più al mondo; Queste sono regole di ricerca, non un elenco di elementi visibili.

Comportamento

Vengono letti i dati già scaricati dal client. Il comando non apre il contenitore, non sposta elementi né scarica oggetti dall'intero server.
Array - array con indici a partire da 0. Salvalo in var, controlla ArrayLength prima di accedere. Gli elementi potrebbero scomparire dal mondo dopo aver scattato una foto: controlla Exists(serial) prima di agire.
Nel client, l'insieme appartiene allo stato generale degli script del profilo. L'array è una copia: IgnoreOff(serial) cancella un'eccezione, IgnoreReset cancella tutto serial. Non disabilitano le regole selezionate type/hue; richiedono SelectIgnoreList, DeleteIgnoreList o ClearIgnoreList. GetContent/GetEquipment e GetWorldItems senza argomenti non applicano questo filtro da soli.

Script C# autonomi

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

1. Ottieni la dimensione dell'elenco: script diretto

Parametri e flusso di esecuzione:

Non ci sono parametri; viene letta un'istantanea delle ovvie eccezioni serial. Un array vuoto non significa che mancano le regole denominate type/hue.
Lunghezza - numero di record/ID. Questo non è l'importo dell'importo in pile. L'elenco vuoto dà 0.

var items = UO.GetIgnoreList();
UO.Print(Convert.ToString(ArrayLength(items)));

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

2. Attraversa tutto trovato ID - funzione script

Parametri e flusso di esecuzione:

Non ci sono parametri; viene letta un'istantanea delle ovvie eccezioni serial. Un array vuoto non significa che mancano le regole denominate type/hue.
elementi[i] — numerico serial. Hex viene utilizzato solo per l'output. Il ciclo non accede all'ultimo indice.

return  RunScenario();
 object? RunScenario()
{
    var items = UO.GetIgnoreList();
    var i = 0;
    while (Truth(i < ArrayLength(items)))
    {
        UO.Print("0x" + Hex(items[i]));
        i = i + 1;
    }

    return null;
}

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

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

Parametri e flusso di esecuzione:

Non ci sono parametri; viene letta un'istantanea delle ovvie eccezioni serial. Un array vuoto non significa che mancano le regole denominate type/hue.
Vengono controllate due cose diverse: il record nell'istantanea e l'esistenza dell'oggetto adesso. L'ordine senza una cernita esplicita non significa vicinanza.

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

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

        return null;
    }

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

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

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "getignorelist":

                    return new InjectionValue(bridge.GetIgnoreList().Select(value => new InjectionValue(value)).ToArray());

UO.GetWorldItems

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

Firme C#

dynamic UO.GetWorldItems();
dynamic UO.GetWorldItems(object? @type);
dynamic UO.GetWorldItems(object? @type, object? color);
dynamic UO.GetWorldItems(object? @type, object? color, object? distance);
dynamic UO.GetWorldItems(object? @type, object? color, object? distance, object? container);
dynamic UO.GetWorldItems(object? @type, object? color, object? distance, object? container, object? nearest);
dynamic UO.GetWorldItems(object? @type, object? color, object? distance, object? container, object? nearest, object? maxZ);

Restituisce un array ID di elementi del mondo o il contenitore selezionato.

Parametri

type - Primo argomento della forma filtrata: graphic/type, -1 o 0xFFFF - qualsiasi. Questo non è serial. Senza tutti gli argomenti, viene utilizzato un modulo separato senza filtri.
color - Tonalità; predefinito - 1, qualsiasi colore. 0xFFFF accetta anche qualsiasi hue.
distance — Raggio nelle celle lungo X/Y. Valore negativo o assenza utilizzare FindDistance; 0 significa la stessa cella. Per un contenitore, viene controllata la distanza dal contenitore, non i suoi X/Y interni.
container - Impostazione predefinita a terra. ground, numerico 0/1 e le loro corde sono rettificate. backpack, my e numerico -1 sono il contenuto diretto dello zaino. Seriale/stringa esadecimale/alias del contenitore: il suo contenuto diretto; self seleziona gli elementi il cui genitore è un personaggio. Un nome sconosciuto e uno zaino mancante danno un array vuoto, non una terra.
nearest — Predefinito false. true ordina per distanza, quindi per numerico serial. Per un contenitore, la distanza per tutti i risultati è la stessa.
maxZ — Differenza di altezza consentita rispetto a self. Valore negativo o assenza utilizzare FindVertical; 0 richiede la stessa altezza. In un contenitore viene presa l'altezza del contenitore stesso.

Valore restituito

Array - serial/ID elementi, non type, coordinate o importo. Un array vuoto senza corrispondenze. GetWorldItems() restituisce tutti gli articoli caricati all'esterno dei contenitori senza Ignore/range/height; GetWorldItems(type,...) utilizza i filtri elencati e Ignore. NPC/giocatori non sono inclusi in nessun modulo.

Comportamento

Vengono letti i dati già scaricati dal client. Il comando non apre il contenitore, non sposta elementi né scarica oggetti dall'intero server.
Array - array con indici a partire da 0. Salvalo in var, controlla ArrayLength prima di accedere. Gli elementi potrebbero scomparire dal mondo dopo aver scattato una foto: controlla Exists(serial) prima di agire.
La foto FindItem/FindCount/GetFoundItems non cambia. La squadra non apre il contenitore né esamina i sacchi chiusi.
Per disabilitare le restrizioni, -1 non è sufficiente: si tratta della selezione dell'impostazione corrente, non del raggio infinito. Specificare la distanza non negativa desiderata/maxZ oppure utilizzare il modulo senza argomenti per tutti gli oggetti terrestri caricati.

Script C# autonomi

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

1. Conta tutti gli oggetti terrestri caricati - script diretto

Parametri e flusso di esecuzione:

Nessun parametro: modulo speciale senza filtri.
Il risultato non indica tutti gli elementi della mappa o del server. Ignore non si applica qui.

var items = UO.GetWorldItems();
UO.Print(Convert.ToString(ArrayLength(items)));

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

2. Trova lo stack più vicino del tipo e della funzione di script colore desiderati

Parametri e flusso di esecuzione:

type=0x0EED — oro, colore=-1 — qualsiasi; distanza=5, contenitore=ground, più vicino=true, maxZ=3.
La prima voce è l'elemento non ignorabile con la corrispondenza più vicina; la distanza non controlla i muri né ostacola l'accessibilità.

return  RunScenario();
 object? RunScenario()
{
    var items = UO.GetWorldItems(0x0EED, -1, 5, "ground", true, 3);
    if (Truth(ArrayLength(items) > 0))
    {
        var item = items[0];
        if (Truth(UO.Exists(item)))
        {
            UO.Print("Nearest ID: 0x" + Hex(item));
        }
    }

    return null;
}

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

3. Conta il contenuto diretto dello zaino - classe di script

Parametri e flusso di esecuzione:

Qualsiasi type/colore; my seleziona uno zaino. La distanza 20 e la differenza Z 255 si riferiscono al contenitore. false conserva l'ordine originale.
Vengono conteggiati gli oggetti diretti, non le unità in pile e non il contenuto dei sacchetti annidati. Senza uno zaino, viene restituito un Array vuoto.

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

     public object? RunScenario()
    {
        var items = UO.GetWorldItems(-1, -1, 20, "my", false, 255);
        UO.Print(Convert.ToString(ArrayLength(items)));
        return null;
    }

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

Implementazione del comando

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

`UO.GetWorldItems()` — `UO.GetWorldItems()`

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "getworlditems":

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

`UO.GetWorldItems(type)` — `UO.GetWorldItems(Any)`

Parametri: type (Any)

Risultato: dynamic / Any.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.RegisterCompactSearchApi [GetWorldItems].
InjectionScript.Runtime.InjectionApiUO.CompactGetWorldItems: CompactGetWorldItems(values).

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 => CompactGetWorldItems(values)

`UO.GetWorldItems(type, color)` — `UO.GetWorldItems(Any,Any)`

Parametri: type (Any), color (Any)

Risultato: dynamic / Any.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.RegisterCompactSearchApi [GetWorldItems].
InjectionScript.Runtime.InjectionApiUO.CompactGetWorldItems: CompactGetWorldItems(values).

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 => CompactGetWorldItems(values)

`UO.GetWorldItems(type, color, distance)` — `UO.GetWorldItems(Any,Any,Any)`

Parametri: type (Any), color (Any), distance (Any)

Risultato: dynamic / Any.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.RegisterCompactSearchApi [GetWorldItems].
InjectionScript.Runtime.InjectionApiUO.CompactGetWorldItems: CompactGetWorldItems(values).

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 => CompactGetWorldItems(values)

`UO.GetWorldItems(type, color, distance, container)` — `UO.GetWorldItems(Any,Any,Any,Any)`

Parametri: type (Any), color (Any), distance (Any), container (Any)

Risultato: dynamic / Any.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.RegisterCompactSearchApi [GetWorldItems].
InjectionScript.Runtime.InjectionApiUO.CompactGetWorldItems: CompactGetWorldItems(values).

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 => CompactGetWorldItems(values)

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

Parametri: type (Any), color (Any), distance (Any), container (Any), nearest (Any)

Risultato: dynamic / Any.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.RegisterCompactSearchApi [GetWorldItems].
InjectionScript.Runtime.InjectionApiUO.CompactGetWorldItems: CompactGetWorldItems(values).

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 => CompactGetWorldItems(values)

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

Parametri: type (Any), color (Any), distance (Any), container (Any), nearest (Any), maxZ (Any)

Risultato: dynamic / Any.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.RegisterCompactSearchApi [GetWorldItems].
InjectionScript.Runtime.InjectionApiUO.CompactGetWorldItems: CompactGetWorldItems(values).

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 => CompactGetWorldItems(values)

UO.Ignore

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

Firme C#

void UO.Ignore(object? objID);
void UO.Ignore(object? id, object? stateValue);

Aggiunge o rimuove serial dalla normale lista di ricerca ignorata.

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.
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.
stateValue — Modalità opzionale. Il numero 0 si spegne, un numero diverso da zero si accende. Le righe "off", "false" (senza distinzione tra maiuscole e minuscole) ed esattamente "0" sono disattivate; qualsiasi altra riga include. Senza un argomento mode: aggiungi.

Valore restituito

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

Comportamento

Ignore(id) chiama bridge.Ignore(serial), che aggiunge serial a State.IgnoredSerials. Ignore(id,stateValue) seleziona Ignore o Unignore. Qualsiasi stringa non vuota non può essere considerata vera: le parole di escape elencate vengono elaborate separatamente.
Questo è un filtro di ricerca, non nasconde o elimina un oggetto. I filtri con nome di tipo AddIgnoreList sono memorizzati separatamente.
In un normale host client, questi dati di stato vengono presi dal gestore GetPersistentState e sono comuni a script/chat/macro dello stesso mondo/profilo e non appartengono a uno script. Un altro processo o un InjectionRuntimeState apparentemente separato ha uno stato diverso. Caricare/cancellare un profilo può sostituirlo; salvati serial vengono ancora confrontati con il mondo caricato.

Script C# autonomi

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

Aggiunge o rimuove serial dalla normale lista di ricerca ignorata.

UO.Ignore("lasttarget");

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

Ignore(id) chiama bridge.Ignore(serial), che aggiunge serial a State.IgnoredSerials. Ignore(id,stateValue) seleziona Ignore o Unignore. Qualsiasi stringa non vuota non può essere considerata vera: le parole di escape elencate vengono elaborate separatamente.

return  RunScenario();
 object? RunScenario()
{
    UO.Ignore("lasttarget", "off");
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

Questo è un filtro di ricerca, non nasconde o elimina un oggetto. I filtri con nome di tipo AddIgnoreList sono memorizzati separatamente.

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.Ignore(id, 1);
            UO.Print(UO.GetIgnoreList());
            UO.Ignore(id, 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.Ignore(objID)` — `UO.Ignore(Any)`

Parametri: objID (Any/Integer/String)

Risultato: void / Unit.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "ignore": bridge.Ignore(Arg(0)); return InjectionValue.Unit;

`UO.Ignore(objID)` — `UO.Ignore(Integer)`

Parametri: objID (Any/Integer/String)

Risultato: void / Unit.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

public void Ignore(int id) => bridge.Ignore(id);

`UO.Ignore(objID)` — `UO.Ignore(String)`

Parametri: objID (Any/Integer/String)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Ignore.
InjectionScript.Runtime.InjectionApiUO.Ignore: Ignore(GetObject(id)).
InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(id).

Codice interno di implementazione; non è uno script autonomo.

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

`UO.Ignore(id, stateValue)` — `UO.Ignore(Any,Any)`

Parametri: id (Any), stateValue (Any)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Ignore.
InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(id).
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(stateValue).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Ignore: bridge.Ignore(serial).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Unignore: bridge.Unignore(serial).

Codice interno di implementazione; non è uno script autonomo.

public void Ignore(InjectionValue id, InjectionValue stateValue)

        {

            int serial = GetObject(id);

            bool enabled = stateValue.Kind != InjectionValueKind.String

                ? NumberConversions.ToInt(stateValue) != 0

                : !stateValue.String.Equals("off", StringComparison.OrdinalIgnoreCase)

                    && !stateValue.String.Equals("false", StringComparison.OrdinalIgnoreCase)

                    && stateValue.String != "0";



            if (enabled)

                bridge.Ignore(serial);

            else

                bridge.Unignore(serial);

        }

UO.IgnoreOff

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

Firme C#

void UO.IgnoreOff(object? objID);

Rimuove un serial dalla normale lista da ignorare.

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

Bridge.Unignore rimuove ID da State.IgnoredSerials. Gli altri filtri serial e quelli denominati AddIgnoreList non vengono cancellati; gli oggetti non vengono rimossi dal mondo.
Modifica locale del filtro di ricerca; i pacchetti non vengono inviati.
In un normale host client, questi dati di stato vengono presi dal gestore GetPersistentState e sono comuni a script/chat/macro dello stesso mondo/profilo e non appartengono a uno script. Un altro processo o un InjectionRuntimeState apparentemente separato ha uno stato diverso. Caricare/cancellare un profilo può sostituirlo; salvati serial vengono ancora confrontati con il mondo caricato.

Script C# autonomi

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

Rimuove un serial dalla normale lista da ignorare.

var id = UO.GetSerial("lasttarget");
if (Truth(UO.Exists(id)))
{
    UO.IgnoreOff(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:

Bridge.Unignore rimuove ID da State.IgnoredSerials. Gli altri filtri serial e quelli denominati AddIgnoreList non vengono cancellati; gli oggetti non vengono rimossi dal mondo.

return  RunScenario();
 object? RunScenario()
{
    var id = UO.GetSerial("self");
    if (Truth(UO.Exists(id)))
    {
        UO.IgnoreOff(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:

Modifica locale del filtro di ricerca; i pacchetti non vengono inviati.

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

Parametri: objID (Any)

Risultato: void / Unit.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "ignoreoff": bridge.Unignore(Arg(0)); return InjectionValue.Unit;

UO.IgnoreReset

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

Firme C#

void UO.IgnoreReset();

Cancella l'elenco normale di serial ignorati.

Parametri

Non ci sono parametri.

Valore restituito

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

Comportamento

Bridge.IgnoreReset chiama State.IgnoredSerials.Clear. Rimuove tutti i serial da questo filtro, compresi quelli aggiunti da un'altra ricerca nella sessione complessiva del bridge.
Non cancella il nome AddIgnoreList, elimina oggetti o reimposta i risultati di FindType.
In un normale host client, questi dati di stato vengono presi dal gestore GetPersistentState e sono comuni a script/chat/macro dello stesso mondo/profilo e non appartengono a uno script. Un altro processo o un InjectionRuntimeState apparentemente separato ha uno stato diverso. Caricare/cancellare un profilo può sostituirlo; salvati serial vengono ancora confrontati con il mondo caricato.

Script C# autonomi

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

Cancella l'elenco normale di serial ignorati.

UO.IgnoreReset();

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

Bridge.IgnoreReset chiama State.IgnoredSerials.Clear. Rimuove tutti i serial da questo filtro, compresi quelli aggiunti da un'altra ricerca nella sessione complessiva del bridge.

return  RunScenario();
 object? RunScenario()
{
    UO.Print(UO.GetIgnoreList());
    UO.IgnoreReset();
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

Non cancella il nome AddIgnoreList, elimina oggetti o reimposta i risultati di FindType.

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.Ignore("lasttarget");
        UO.IgnoreReset();
        UO.Print(UO.GetIgnoreList());
        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.IgnoreReset()` — `UO.IgnoreReset()`

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

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

UO.InfoFindList

Firme C#

string UO.InfoFindList();

Comportamento e risultato

Il contesto determina la visualizzazione: i comandi della chat grafica aprono una tabella con campi, valori, Ctrl+C e scorrimento. Gli script C# ricevono testo senza finestre o mirino, anche con il gioco aperto. Sono disponibili solo i dati noti al client.

Info e InfoTile senza argomenti attivano il mirino nella chat grafica. In uno script Info() legge l’ultimo oggetto bersaglio o il giocatore; InfoTile() il terreno sotto il giocatore. serial, type e coordinate selezionano un elemento preciso. Il terzo argomento di InfoTile(x,y,map) è la mappa.

Parametri

Nessun parametro.

Configurare il prefisso in C# Scripts IDE; # è un esempio. Separare i parametri con spazi e racchiudere il testo fra virgolette. id significa serial, type significa graphic. xy x y [z] seleziona il primo oggetto caricato nel punto; type da solo il primo risultato. Il terzo argomento di InfoTile(x,y,map) è la mappa, non Z.

Comandi chat

#infofindlist

Esempi C# completi

Ogni blocco è un .csx completo. Sostituire serial, tipi e coordinate di esempio. Ordine e argomenti C# nominati seguono la firma.

1

UO.Print(UO.InfoFindList());

2

string ReadDefinitions() => UO.InfoFindList();
UO.Print(ReadDefinitions());

3

string report = UO.InfoFindList();
foreach (string line in report.Split('\n'))
    UO.Print(line);

4

new CommandSample().Execute(UO);

sealed class CommandSample
{
    public void Execute(global::ClassicUO.CSharp.CSharpGameApi api)
    {
        api.Print(api.InfoFindList());
    }
}

Chiamate interne

CSharpGameApi.InfoFindList
  -> CSharpScriptGlobals
  -> InjectionScript.Runtime.InjectionApiUO.InfoFindList

ClassicUOInjectionApiBridge -> YokoInfoReport -> YokoInfoGump

UO.MFGI

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

Firme C#

void UO.MFGI();

Stampa l'elenco corrente dei risultati della ricerca.

Parametri

Non ci sono parametri.

Valore restituito

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

Comportamento

ExecuteLegacyManualAlias legge GetFoundItems, formatta ciascuno serial come 0xXXXXXXXX e concatena le righe con un "|" delimitatore. Non viene eseguita alcuna nuova ricerca; una lista vuota restituisce una stringa vuota.
Modifica o visualizza solo i dati locali specificati. Questo comando non ha la conferma del server.

Script C# autonomi

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

Stampa l'elenco corrente dei risultati della ricerca.

UO.MFGI();

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

ExecuteLegacyManualAlias legge GetFoundItems, formatta ciascuno serial come 0xXXXXXXXX e concatena le righe con un "|" delimitatore. Non viene eseguita alcuna nuova ricerca; una lista vuota restituisce una stringa vuota.

return  RunScenario();
 object? RunScenario()
{
    UO.FindType("0x0E21");
    UO.MFGI();
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

Modifica o visualizza solo i dati locali specificati. Questo comando non ha la conferma del server.

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

     public object? RunScenario()
    {
        UO.MFGI();
        UO.Print(UO.GetArrayLength(UO.GetFoundItems()));
        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.MFGI()` — `UO.MFGI()`

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
InjectionScript.Runtime.InjectionApiUO.SystemMessage: SystemMessage(string.Join(" | ", bridge.GetFoundItems().Select(id => $"0x{id:X8}"))).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetFoundItems: bridge.GetFoundItems().

Codice interno di implementazione; non è uno script autonomo.

case "mfgi":

                    SystemMessage(string.Join(" | ", bridge.GetFoundItems().Select(id => $"0x{id:X8}")));

                    break;

UO.SelectIgnoreList

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

Firme C#

void UO.SelectIgnoreList(object? list);

Attiva/disattiva il filtro di ricerca denominato attivo. È utile modificare l'insieme di eccezioni tra mining, sorting e targeting senza eliminare le regole salvate. Questo comando non esegue la ricerca stessa.

Parametri

list — Nome arbitrario non vuoto, ad esempio "loot_skip". Il nome non fa distinzione tra maiuscole e minuscole. Questo non è il nome dell'elemento, non il contenitore serial e non il nome di FindList. Anche la stringa vuota "" è accettabile qui: disabilita le regole con nome.

Valore restituito

void - nessun valore. Utilizzare su una riga separata senza risultato var = e senza selezionare =true. Il comando modifica il filtro locale; non restituisce il numero di elementi e non invia nulla al server.

Comportamento

Un nome inesistente seleziona un filtro vuoto. Il defunto AddIgnoreList con questo nome inizierà ad agire nelle prossime ricerche. Normale Ignore(serial) continua a funzionare indipendentemente dalla scelta.
L'elenco denominato contiene le regole graphic/type + hue, e il normale Ignore contiene lo specifico serial. Si tratta di filtri diversi: vengono combinati quando la ricerca li supporta. Gli oggetti rimangono visibili e accessibili per dirigere UseObject/MoveItem; questo non è Hide o divieto di azioni.
Il nome dell'elenco non fa distinzione tra maiuscole e minuscole; gli spazi sul bordo vengono rimossi. È attivo un elenco denominato, inizialmente predefinito. AddIgnoreList non lo seleziona automaticamente. SelectIgnoreList("") disabilita solo il filtro indicato.
Le regole si applicano alle nuove ricerche, inclusi gli elementi caricati DOPO essere stati aggiunti. L'array già ricevuto e il risultato precedente FindCount non vengono ricalcolati fino ad una nuova ricerca. Non selezionare un elenco con la regola -1,-1 a meno che tu non voglia escludere tutto.
Il filtro prende in considerazione FindType/FindTypeEx/FindTypesArrayEx, FindList, FindAtCoord, FindNotoriety, Count/CountEx e le selezioni estese GetMobiles, GetWorldItems, UseType, WaitTarget, Attack/AttackNearest/FindMan. includeIgnored=true, dove previsto, bypassa sia serial che type/hue. L'enumerazione completa GetContent/GetEquipment, GetWorldItems() senza argomenti e quella verbale FindMobile(umano,vicino,...) non utilizzano queste regole.
GetIgnoreList restituisce solo serial aggiunto esplicitamente; le righe dell'elenco denominato non sono incluse in questo array. IgnoreReset cancella l'intero filtro serial, IgnoreOff(serial) rimuove un'eccezione serial; le regole nominate vengono preservate. ClearIgnoreList() senza argomenti cancella entrambe le visualizzazioni.
Lo stato appartiene allo stato generale degli script del profilo cliente; la modifica influisce su altri script con questo stato. Le impostazioni sono incluse nell'istantanea salvata. Dopo aver modificato le regole, un altro script può già eseguire una ricerca con l'istantanea scattata in precedenza: la ricerca successiva vedrà l'aggiornamento.
In un normale host client, questi dati di stato vengono presi dal gestore GetPersistentState e sono comuni a script/chat/macro dello stesso mondo/profilo e non appartengono a uno script. Un altro processo o un InjectionRuntimeState apparentemente separato ha uno stato diverso. Caricare/cancellare un profilo può sostituirlo; salvati serial vengono ancora confrontati con il mondo caricato.

Script C# autonomi

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

1. Cambia modalità di ordinamento - script diretto

Parametri e flusso di esecuzione:

SORT e sort sono un elenco. La ricerca seleziona il primo oggetto zaino consentito; il salvataggio del nome non lo trasferisce.

UO.AddIgnoreList("sort", 0x0EED);
UO.SelectIgnoreList("SORT");
var item = UO.FindType(-1, -1, "backpack");
if (Truth(item != ""))
{
    UO.AddObject("sort_candidate", item);
}

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

2. Disattiva le regole type, salvando i set stessi - funzione script

Parametri e flusso di esecuzione:

Una riga vuota disabilita solo il filtro indicato. Per ripristinarlo in seguito, passare nuovamente il nome impostato.

return  RunScenario();
 object? RunScenario()
{
    UO.SelectIgnoreList("");
    var gold = UO.FindType(0x0EED, -1, "backpack");
    if (Truth(gold != ""))
    {
        UO.AddObject("gold_candidate", gold);
    }

    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. Preparare un filtro dopo aver scelto un nome - classe di script

Parametri e flusso di esecuzione:

Prima di aggiungere la regola in seguito è vuota. Una volta aggiunta, nessuna pila d'oro supera la ricerca successiva, anche se è appena apparsa.

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.SelectIgnoreList("later");
        UO.AddIgnoreList("later", 0x0EED);
        var item = UO.FindType(0x0EED, -1, "ground");
        if (Truth(item == ""))
        {
            UO.Print("Gold is excluded by the selected rule");
        }

        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.SelectIgnoreList(list)` — `UO.SelectIgnoreList(Any)`

Parametri: list (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "selectignorelist": state.SelectedIgnoreList = Text(0).Trim(); break;

UO.SetBadLocation

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

Firme C#

void UO.SetBadLocation(object? x, object? y);

Aggiunge X/Y all'elenco delle celle proibite per i seguenti percorsi MoveXY, NewMoveXY, MoveXYZ, PMove e richiede GetPathArray/GetPathArray3D.

Parametri

x — Mondo X della cella esclusa.
y — Mondo Y della cella esclusa.

Valore restituito

void - nessun valore restituito. Chiama su una linea separata; non è true/false o il numero di passi.

Comportamento

La chiave è composta da X/Y, nessuna mappa e Z. Le coordinate devono essere numeri interi compresi tra 0..65535; uscire dall'intervallo provoca un errore di script.
I divieti si applicano al runtime dello script chiamante. La nuova rotta o richiesta ne riceve uno snapshot. Un percorso già in esecuzione salva la sua istantanea, incluso il ricalcolo interno. Dopo aver modificato l'elenco, iniziare un nuovo percorso.
Questa non è una modifica alla mappa: il normale movimento manuale e altri percorsi di runtime non ricevono questo divieto. Puoi lasciare la casella originale, anche se è contrassegnata come vietata.
In un normale host client, questi dati di stato vengono presi dal gestore GetPersistentState e sono comuni a script/chat/macro dello stesso mondo/profilo e non appartengono a uno script. Un altro processo o un InjectionRuntimeState apparentemente separato ha uno stato diverso. Caricare/cancellare un profilo può sostituirlo; salvati serial vengono ancora confrontati con il mondo caricato.

Script C# autonomi

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.SetBadLocation");
UO.SetBadLocation(UO.GetX() + 1, UO.GetY());

1. Escludi la cella vicina dal calcolo - script diretto

Parametri e flusso di esecuzione:

X/Y: cella a est del personaggio.
Se è possibile un attraversamento, viene restituito un altro percorso completo; il personaggio non si muove.

UO.SetBadLocation(UO.GetX() + 1, UO.GetY());
var path = UO.GetPathArray(UO.GetX() + 3, UO.GetY(), true, 0);
UO.Print(Convert.ToString(ArrayLength(path)));

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

2. Aggiungi due celle: funzione script

Parametri e flusso di esecuzione:

Ogni chiamata aggiunge una coppia X/Y.
La ripetizione di una coppia non crea un secondo divieto separato; Z non è un parametro.

return  RunScenario();
 object? RunScenario()
{
    UO.SetBadLocation(1445, 1690);
    UO.SetBadLocation(1445, 1691);
    return null;
}

3. Posiziona un ostacolo noto in una cella adiacente - classe scenario

Parametri e flusso di esecuzione:

Sostituisci le coordinate con una cella davvero impraticabile. Il comando imposta i dati del percorso locale e non crea un oggetto 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()
    {
        int x = UO.GetX() + 1;
        int y = UO.GetY();
        UO.SetBadLocation(x, y);
        UO.Print($"Marked known blocked location: {x},{y}");
        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.SetBadLocation(x, y)` — `UO.SetBadLocation(Any,Any)`

Parametri: x (Any), y (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "setbadlocation":

                {

                    int x = Arg(0), y = Arg(1);

                    if (x < 0 || x > ushort.MaxValue || y < 0 || y > ushort.MaxValue)

                        throw new NativeSubrutineException("UO.SetBadLocation requires world X/Y in 0..65535.");

                    state.BadLocations.Add(x + "," + y);

                    return InjectionValue.Unit;

                }

UO.SetBadObject

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

Firme C#

void UO.SetBadObject(object? objType, object? color, object? radius);

Esclude dai seguenti percorsi e interroga i percorsi delle celle attorno agli oggetti del mondo caricati selezionati da graphic e hue.

Parametri

objType - Grafico/type dell'articolo, 0..65535. 0xFFFF o -1 consente qualsiasi tipo. Questa non è un'istanza specifica di serial.
color — Tonalità dell'oggetto, 0..65535. 0xFFFF o -1 consente qualsiasi colore; 0 significa esattamente hue 0.
radius — Raggio nelle celle, 0..255 compreso. 0 esclude una cella articolo. R esclude il quadrato max(abs(dx),abs(dy)) <= R attorno ad esso, comprese le celle diagonali.

Valore restituito

void - nessun valore restituito. Chiama su una linea separata; non è true/false o il numero di passi.

Comportamento

I parametri sono obbligatori. Un intervallo inappropriato provoca un errore di script anziché il troncamento silenzioso del numero.
Le regole vengono accumulate nel runtime corrente. Le regole di corrispondenza vengono combinate: il raggio più grande viene applicato a un elemento. ClearBadObjectList rimuove tutte queste regole.
Vengono presi in considerazione gli elementi dinamici caricati con Container=0, comprese le porte accessibili al client. Gli elementi all'interno dei contenitori, NPC e le statistiche della mappa non vengono selezionati da questo filtro. Per i caratteri utilizzare avoidMobiles, per le singole celle utilizzare SetBadLocation.
Quando avvii MoveXY/NewMoveXY/MoveXYZ/PMove o GetPathArray/GetPathArray3D, viene creata un'istantanea delle regole e delle posizioni degli elementi. Ulteriori modifiche al mondo e all'elenco non modificano questa istantanea; un nuovo lancio riceve nuovi dati.
Il filtro non invia nulla al server, non forza il caricamento del contenuto nel contenitore chiuso e non modifica lo spostamento manuale. Le regole X/Y non hanno un limite Z separato.
In un normale host client, questi dati di stato vengono presi dal gestore GetPersistentState e sono comuni a script/chat/macro dello stesso mondo/profilo e non appartengono a uno script. Un altro processo o un InjectionRuntimeState apparentemente separato ha uno stato diverso. Caricare/cancellare un profilo può sostituirlo; salvati serial vengono ancora confrontati con il mondo caricato.

Script C# autonomi

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.SetBadObject");
UO.SetBadObject(0x398C, 0xFFFF, 1);

1. Ignora oggetti di un certo tipo: script diretto

Parametri e flusso di esecuzione:

ObjType=0x398C - esempio graphic: sostituisci con il tipo di ostacolo presente sul tuo server. Color=0xFFFF seleziona qualsiasi colore; Raggio=1 elimina un quadrato 3×3 attorno a ciascun oggetto corrispondente.
NewMoveXY va cinque celle verso est, con X/Y esatto, a piedi, senza richiamata e con timeout=5000 ms. ok=1 significa raggiungere l'obiettivo; 0 non conferma il bypass.

UO.SetBadObject(0x398C, 0xFFFF, 1);
var ok = UO.NewMoveXY(UO.GetX() + 5, UO.GetY(), true, 0, false, 0, 5000);
UO.Print(Convert.ToString(ok));

2. Controlla il percorso con il colore esatto senza movimento - funzione script

Parametri e flusso di esecuzione:

Colore=0x0044 seleziona solo hue e Raggio=0 esclude solo la cella occupata dall'elemento. ClearBadObjectList rimuove le precedenti regole di tipo e colore.
GetPathArray restituisce le voci [x,y,z], inclusa l'origine. Un array vuoto significa che non esiste un percorso completo dati i vincoli attuali. Il personaggio rimane al suo posto.

return  RunScenario();
 object? RunScenario()
{
    UO.ClearBadObjectList();
    UO.SetBadObject(0x398C, 0x0044, 0);
    var path = UO.GetPathArray(UO.GetX() + 4, UO.GetY(), true, 0);
    UO.Print("Path records: " + Convert.ToString(ArrayLength(path)));
    return null;
}

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

3. Escludi temporaneamente celle di qualsiasi oggetto nel mondo - classe di script

Parametri e flusso di esecuzione:

ObjType=-1 e Color=-1 sono entrambi caratteri jolly. Raggio=0 esclude le celle di tutti gli oggetti del mondo caricati, ma non NPC o il contenuto delle borse.
La pulizia si applica alle richieste future. Il percorso già ricevuto viene salvato; si tratta di una serie di coordinate, non del percorso attivo.

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.SetBadObject(-1, -1, 0);
        var path = UO.GetPathArray(UO.GetX() + 2, UO.GetY(), true, 0);
        UO.ClearBadObjectList();
        UO.Print(Convert.ToString(ArrayLength(path)));
        return null;
    }

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

Implementazione del comando

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

`UO.SetBadObject(objType, color, radius)` — `UO.SetBadObject(Any,Any,Any)`

Parametri: objType (Any), color (Any), radius (Any)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
InjectionScript.Runtime.InjectionApiUO.ResolveType: ResolveType(arguments[0]).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(1).

Codice interno di implementazione; non è uno script autonomo.

case "setbadobject":

                {

                    int type = ResolveType(arguments[0]), hue = Arg(1), radius = Arg(2);

                    if (type < -1 || type > ushort.MaxValue || hue < -1 || hue > ushort.MaxValue || radius < 0 || radius > byte.MaxValue)

                        throw new NativeSubrutineException("UO.SetBadObject requires type/color 0..65535 (or -1) and radius 0..255.");

                    state.BadObjects.Add(type + "," + hue + "," + radius);

                    return InjectionValue.Unit;

                }

IT UO Topic search Part 2 - LIHACHTETAN/ClassicUO-Bad-Newbie-CSharp-Scripts-IDE GitHub Wiki

Ricerca — 2

Parti del riferimento

Riferimento completo dei comandi

UO.FindMan

Firme C#

Parametri

Valore restituito

Comportamento

Script C# autonomi

Esempio semplice

1. Trova e salva l'alleato più vicino: script diretto

2. Specificare ciascuna condizione prima di ulteriori azioni: funzione dello script

3. Trova prima mobile con la specifica classe di script hue

Implementazione del comando

UO.FindMan() — UO.FindMan()

UO.FindMan(notoriety) — UO.FindMan(Any)

UO.FindMan(notoriety, distance) — UO.FindMan(Any,Any)

UO.FindMan(notoriety, distance, nearest) — UO.FindMan(Any,Any,Any)

UO.FindMan(notoriety, distance, nearest, maxZ) — UO.FindMan(Any,Any,Any,Any)

UO.FindMan(notoriety, distance, nearest, maxZ, body) — UO.FindMan(Any,Any,Any,Any,Any)

UO.FindMan(notoriety, distance, nearest, maxZ, body, color) — UO.FindMan(Any,Any,Any,Any,Any,Any)

UO.FindMan(notoriety, distance, nearest, maxZ, body, color, includeSelf) — UO.FindMan(Any,Any,Any,Any,Any,Any,Any)

UO.FindMobile

Firme C#

Parametri

Valore restituito

Comportamento

Script C# autonomi

Esempio semplice

1. Cerca e controlla il risultato: script diretto

2. Combinazione di condizioni con raggio temporale - funzione script

3. Funzione completa per filtro composito - Classe Script

4. Trova la creatura e controlla separatamente la distanza esatta - sceneggiatura diretta

Implementazione del comando

UO.FindMobile() — UO.FindMobile()

UO.FindMobile(stateFilter) — UO.FindMobile(Any)

UO.FindMobile(stateFilter, rangeFilter) — UO.FindMobile(Any,Any)

UO.FindMobile(stateFilter, rangeFilter, verticalFilter) — UO.FindMobile(Any,Any,Any)

UO.FindMobile(stateFilter, rangeFilter, verticalFilter, directionOrKind) — UO.FindMobile(Any,Any,Any,Any)

UO.FindMobile(stateFilter, rangeFilter, verticalFilter, directionFilter, kindFilter) — UO.FindMobile(Any,Any,Any,Any,Any)

UO.FindNotoriety

Firme C#

Parametri

Valore restituito

Comportamento

Script C# autonomi

Esempio semplice

1. Conta uomini e donne con reputazione nemica - sceneggiatura diretta

2. Il più vicino dei due stati con altezza limitata: funzione script

3. Matrice di stati nel secondo parametro: classe di scenario

Implementazione del comando

UO.FindNotoriety(type, notoriety) — UO.FindNotoriety(Any,Any)

UO.FindNotoriety(type, notoriety, distance) — UO.FindNotoriety(Any,Any,Any)

UO.FindNotoriety(type, notoriety, distance, nearest) — UO.FindNotoriety(Any,Any,Any,Any)

UO.FindNotoriety(type, notoriety, distance, nearest, maxZ) — UO.FindNotoriety(Any,Any,Any,Any,Any)

UO.FindNotoriety(type, notoriety, distance, nearest, maxZ, color) — UO.FindNotoriety(Any,Any,Any,Any,Any,Any)

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

UO.FindQuantity

Firme C#

Parametri

Valore restituito

Comportamento

Script C# autonomi

Esempio semplice

1. Misura i risultati della ricerca sull'oro: script diretto

2. Confronta elementi e unità - Funzione script

3. Salva il risultato fino alla ricerca successiva - classe di script

Implementazione del comando

UO.FindQuantity() — UO.FindQuantity()

UO.FindType

Firme C#

Parametri

Valore restituito

Comportamento

Script C# autonomi

Esempio semplice

1. Trova l'oro nel livello più alto dello zaino ed elabora la mancanza di risultato - sceneggiatura diretta

2. Cerca ricorsivamente un oggetto nelle borse dello zaino caricate - funzione script

3. Trova il personaggio più vicino con una delle due reputazioni: classe dello scenario

`UO.FindMan()` — `UO.FindMan()`

`UO.FindMan(notoriety)` — `UO.FindMan(Any)`

`UO.FindMan(notoriety, distance)` — `UO.FindMan(Any,Any)`

`UO.FindMan(notoriety, distance, nearest)` — `UO.FindMan(Any,Any,Any)`

`UO.FindMan(notoriety, distance, nearest, maxZ)` — `UO.FindMan(Any,Any,Any,Any)`

`UO.FindMan(notoriety, distance, nearest, maxZ, body)` — `UO.FindMan(Any,Any,Any,Any,Any)`

`UO.FindMan(notoriety, distance, nearest, maxZ, body, color)` — `UO.FindMan(Any,Any,Any,Any,Any,Any)`

`UO.FindMan(notoriety, distance, nearest, maxZ, body, color, includeSelf)` — `UO.FindMan(Any,Any,Any,Any,Any,Any,Any)`

`UO.FindMobile()` — `UO.FindMobile()`

`UO.FindMobile(stateFilter)` — `UO.FindMobile(Any)`

`UO.FindMobile(stateFilter, rangeFilter)` — `UO.FindMobile(Any,Any)`

`UO.FindMobile(stateFilter, rangeFilter, verticalFilter)` — `UO.FindMobile(Any,Any,Any)`

`UO.FindMobile(stateFilter, rangeFilter, verticalFilter, directionOrKind)` — `UO.FindMobile(Any,Any,Any,Any)`

`UO.FindMobile(stateFilter, rangeFilter, verticalFilter, directionFilter, kindFilter)` — `UO.FindMobile(Any,Any,Any,Any,Any)`

`UO.FindNotoriety(type, notoriety)` — `UO.FindNotoriety(Any,Any)`

`UO.FindNotoriety(type, notoriety, distance)` — `UO.FindNotoriety(Any,Any,Any)`

`UO.FindNotoriety(type, notoriety, distance, nearest)` — `UO.FindNotoriety(Any,Any,Any,Any)`

`UO.FindNotoriety(type, notoriety, distance, nearest, maxZ)` — `UO.FindNotoriety(Any,Any,Any,Any,Any)`

`UO.FindNotoriety(type, notoriety, distance, nearest, maxZ, color)` — `UO.FindNotoriety(Any,Any,Any,Any,Any,Any)`

`UO.FindNotoriety(type, notoriety, distance, nearest, maxZ, color, container)` — `UO.FindNotoriety(Any,Any,Any,Any,Any,Any,Any)`

`UO.FindQuantity()` — `UO.FindQuantity()`

`UO.FindType(type)` — `UO.FindType(Any)`

`UO.FindType(type, color)` — `UO.FindType(Any,Any)`

`UO.FindType(type, color, container)` — `UO.FindType(Any,Any,Any)`

`UO.FindType(type, color, container, range)` — `UO.FindType(Any,Any,Any,Any)`

`UO.FindType(type, color, container, distance, recursive)` — `UO.FindType(Any,Any,Any,Any,Any)`

`UO.FindType(type, color, container, distance, notoriety, nearest)` — `UO.FindType(Any,Any,Any,Any,Any,Any)`

`UO.FindType(type, color, container, distance, notoriety, nearest, maxZ)` — `UO.FindType(Any,Any,Any,Any,Any,Any,Any)`

`UO.FindType(type, color, container, distance, notoriety, nearest, maxZ, mobileOnly)` — `UO.FindType(Any,Any,Any,Any,Any,Any,Any,Any)`

`UO.FindType(type, color, container, distance, notoriety, nearest, maxZ, mobileOnly, itemOnly)` — `UO.FindType(Any,Any,Any,Any,Any,Any,Any,Any,Any)`

`UO.FindType(type, color, container, distance, notoriety, nearest, maxZ, mobileOnly, itemOnly, includeIgnored)` — `UO.FindType(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)`

`UO.FindType(type, color, container, distance, notoriety, nearest, maxZ, mobileOnly, itemOnly, includeIgnored, includeSelf)` — `UO.FindType(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)`

`UO.FindType(type, color, container, distance, notoriety, nearest, maxZ, mobileOnly, itemOnly, includeIgnored, includeSelf, aliveOnly)` — `UO.FindType(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)`

`UO.FindType(type, color, container, distance, notoriety, nearest, maxZ, mobileOnly, itemOnly, includeIgnored, includeSelf, aliveOnly, visibleOnly)` — `UO.FindType(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)`

`UO.FindType(type, color, container, distance, notoriety, nearest, maxZ, mobileOnly, itemOnly, includeIgnored, includeSelf, aliveOnly, visibleOnly, nameMask)` — `UO.FindType(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)`

`UO.FindTypeEx(objType, color, container, inSub)` — `UO.FindTypeEx(Any,Any,Any,Any)`

`UO.FindTypesArrayEx(objTypes, colors, containers, inSub)` — `UO.FindTypesArrayEx(Any,Any,Any,Any)`

`UO.FindVertical()` — `UO.FindVertical()`

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

`UO.GetFindedList(userList)` — `UO.GetFindedList(Any)`