Skip to content

IT UO Topic combat

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

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

Combattere

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

Attacco, modalità di combattimento, abilità delle armi e cura delle bende. La richiesta del client e l'azione intrapresa dal server sono diverse.

Sezioni

Argomento Comandi e spiegazioni
Attack UO.Attack
AttackNearest UO.AttackNearest
LastAttack UO.LastAttack
WarMode UO.WarMode
WarTarget UO.WarTargetID
Abilità delle armi UO.GetWeaponAbilities · UO.GetAbilityID · UO.GetAbilityName · UO.GetActiveAbility
Primary Ability UO.UsePrimaryAbility
Secondary Ability UO.UseSecondaryAbility
Special Moves UO.Specmove
BandageSelf UO.BandageSelf

Tutti i comandi del tema

Attack

UO.Attack · UO.AttackNearest · UO.LastAttack · UO.WarMode · UO.IsWarMode · UO.SetWarMode · UO.WarTargetID

Abilità delle armi

UO.GetWeaponAbilities · UO.GetAbilityID · UO.GetAbilityName · UO.GetActiveAbility · UO.UseAbility · UO.UsePrimaryAbility · UO.UseSecondaryAbility · UO.Specmove

BandageSelf

UO.BandageSelf

Corsi di attrezzatura personalizzata

UO.SetClassMask · UO.ClearClassMask · UO.AttackNearest

I nomi dei gruppi e le tipologie di capi indossati sono specificati dalla sceneggiatura; l'ordine dei nomi fino a | specifica la priorità.

Esempi sull'argomento

Ogni carta comando ha diversi scenari indipendenti: codice diretto, funzioni e classi. Di seguito sono selezionati brevi scenari; restrizioni e un'analisi completa sono nelle carte.

UO.Attack

Parametri, risultato e tutti gli scenari

var selected = UO.LastTarget();
var allowed = UO.GetMobiles(10, "5|6", -1, 8, false, false, true, true);
var i = 0;
while (Truth(i < ArrayLength(allowed)))
{
    if (Truth(allowed[i] == selected))
    {
        UO.Attack(selected);
        return null;
    }
    i += 1;
}
UO.Print("Selected target does not pass the filters");

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;

UO.GetWeaponAbilities

Parametri, risultato e tutti gli scenari

var abilities = UO.GetWeaponAbilities();
UO.Print(UO.GetArrayLength(abilities));

Riferimento completo dei comandi

UO.Attack

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

Firme C#

void UO.Attack(object? objID);

Dirige una richiesta di attacco a uno specifico serial. Adatto quando il bersaglio è già stato selezionato dall'utente o trovato da un'altra squadra; Qui non esiste una ricerca indipendente per abbigliamento/distanza.

Parametri

  • objID — Seriale mobile: int, stringa decimale/esadecimale o nome oggetto risolvibile (ad esempio lasttarget o nome AddObject). Non graphic/type o il nome della classe. Argomento richiesto; 0 non è un comando per fermare il combattimento. Per selezionare un bersaglio senza il suo ID usa la ricerca o il bersaglio del gioco.

Valore restituito

void - nessun valore. Scrivi UO.Attack(enemy) su una riga separata, non var result=UO.Attack(...). La fine di una chiamata non conferma un riscontro, un danno o l'accettazione del server.

Comportamento

  • La sfida in sé non respinge morti, distanti, self, alleati, serial vuoti o oggetti. Controlla il target selezionato; preferibilmente filtrato mobile da GetMobiles/FindMan.
  • Viene utilizzato lo standard GameActions.Attack: è possibile il problema di un attacco criminale con EnabledCriminalActionQuery. Durante l'avanzamento normale, LastAttack/NewTargetSystemSerial vengono aggiornati e viene inviato un pacchetto di richiesta di attacco.
  • Il comando non attiva WarMode, non esegue un doppio clic, non calcola un percorso e non avvia un ciclo di attacchi ripetuti. La modalità di combattimento e il combattimento successivo dipendono dal server.
  • Potrebbe verificarsi un errore di risoluzione per una stringa con un nome oggetto sconosciuto. Il test Exists dimostra la presenza di un oggetto, ma non che sia mobile; GetMobiles è dato dai cellulari.

Script C# autonomi

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

Esempio semplice

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

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

UO.Print("Calling UO.Attack");
UO.Attack(UO.LastTarget());

1. Attacca l'ultimo bersaglio vivo selezionato dopo aver controllato - script diretto

Parametri e flusso di esecuzione:

  • lasttarget può essere un oggetto o un personaggio amico. L'elenco consentito esclude questi casi; Attack viene chiamato al massimo una volta.
var selected = UO.LastTarget();
var allowed = UO.GetMobiles(10, "5|6", -1, 8, false, false, true, true);
var i = 0;
while (Truth(i < ArrayLength(allowed)))
{
    if (Truth(allowed[i] == selected))
    {
        UO.Attack(selected);
        return null;
    }
    i += 1;
}
UO.Print("Selected target does not pass the filters");

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

2. Trova prima il nemico, poi attacca quando l'altitudine è disponibile - funzione script

Parametri e flusso di esecuzione:

  • FindMan restituisce serial e non attacca. Il controllo IsDead viene aggiunto separatamente perché FindMan non ha aliveOnly.
return  RunScenario();
 object? RunScenario()
{
    var enemy = UO.FindMan(5, 6, true, 4, -1, -1, false);
    if (Truth(enemy == 0))
    {
        return null;
    }

    if (Truth(UO.IsDead(enemy) == 0))
    {
        UO.AddObject("enemy", enemy);
        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. Bersaglio più vicino con controllo della geometria separato - classe di scenario

Parametri e flusso di esecuzione:

  • GetMobiles è già ordinato dal più vicino=true. Se c'è un muro davanti al primo bersaglio, viene controllato quello successivo; la presenza di visibleOnly non sostituisce di per sé CheckLOS. La verifica del server può variare.
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 targets = UO.GetMobiles(8, 5, -1, 10, true, false, true, true);
        var i = 0;
        while (Truth(i < ArrayLength(targets)))
        {
            var enemy = targets[i];
            if (Truth(UO.CheckLOS(UO.GetX("self"), UO.GetY("self"), UO.GetZ("self"), UO.GetX(enemy), UO.GetY(enemy), UO.GetZ(enemy), UO.WorldNum())))
            {
                UO.Attack(enemy);
                return null;
            }

            i += 1;
        }

        return null;
    }

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

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

Parametri: objID (Any/Integer/String)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "attack": bridge.Attack(Arg(0)); return InjectionValue.Unit;

UO.Attack(objID) — UO.Attack(Integer)

Parametri: objID (Any/Integer/String)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

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

UO.Attack(objID) — UO.Attack(String)

Parametri: objID (Any/Integer/String)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

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

UO.AttackNearest

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

Firme C#

int UO.AttackNearest(object? notoriety);
int UO.AttackNearest(object? notoriety, object? distance);
int UO.AttackNearest(object? notoriety, object? distance, object? body);
int UO.AttackNearest(object? notoriety, object? distance, object? body, object? maxZ);
int UO.AttackNearest(object? notoriety, object? distance, object? body, object? maxZ, object? nearest);
int UO.AttackNearest(object? notoriety, object? distance, object? body, object? maxZ, object? nearest, object? color);
int UO.AttackNearest(object? notoriety, object? distance, object? body, object? maxZ, object? nearest, object? color, object? classMask);
int UO.AttackNearest(object? notoriety, object? distance, object? body, object? maxZ, object? nearest, object? color, object? classMask, object? aliveOnly);
int UO.AttackNearest(object? notoriety, object? distance, object? body, object? maxZ, object? nearest, object? color, object? classMask, object? aliveOnly, object? visibleOnly);

Seleziona un bersaglio di combattimento adatto e lo passa al gestore dell'attacco. I filtri limitano i caratteri accettabili; personalizzato classMask imposta la priorità dell'attrezzatura e della classe, la scelta più vicina all'interno di una classe.

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.
  • 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.
  • 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.
  • nearest - true/1 seleziona il carattere corrispondente più vicino per impostazione predefinita; la stessa distanza è consentita dal serial più piccolo. false/0 mantiene il primo oggetto corrispondente nell'ordine dell'elenco dei clienti, non seleziona quello più lontano. Con classMask si applica prima la priorità di classe e poi la distanza intraclasse.
  • 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.
  • classMask — Nomi di regole predefinite da UO.SetClassMask nello stesso runtime dello script. Ad esempio, "DTMH|hunter|spare" - priorità da sinistra a destra; è consentito anche un array di stringhe. Qualsiasi nome, il caso non è importante. Separatori di riga: |, virgola o ;. Qualsiasi nome sconosciuto/elemento vuoto all'interno dell'elenco deseleziona l'intera selezione: risultato 0, nessun attacco. Questa non è una maschera di bit numerica: 7 non significa tre classi. Un argomento mancante, -1, "-1", "any", "all" o una stringa vuota disabilita separatamente il filtro della classe. Mago/Carro armato/Arciere non sono integrati: senza registrare tali regole, non ci saranno partite.
  • aliveOnly - true/1 esclude i cellulari con IsDead != 0; false/0 non aggiunge questa condizione per impostazione predefinita. Non confrontare HP con zero, non cercare oggetti cadaveri e non garantire che l'obiettivo rimanga in vita dopo essere stato evocato.
  • visibleOnly - true/1 richiede IsVisible=1 secondo lo stato attuale di ClassicUO; false/0 non aggiunge una condizione per impostazione predefinita. Questa è la visibilità dell'oggetto caricato per il client, non un controllo della linea di vista/muro. Per il controllo geometrico è presente un UO.CheckLOS separato con coordinate; il server potrebbe ancora rifiutare l'azione.

Valore restituito

int - serial selezionato mobile, o 0 quando non c'è un target adatto o classMask non è valido. Questa non è una bandiera 1/0, non una body/type, non una distanza o una conferma di uno strike. Controlla il nemico!= 0; nemico == true non è valido in C#: int non è paragonabile a bool. Se ID è diverso da zero, il gestore ClassicUO può ancora mostrare la conferma dell'attacco Innocente; il server può rifiutare l'azione.

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.
  • Il nome è un'etichetta personalizzata, non una professione di server. Puoi chiamare la regola DTMH, my_group o qualsiasi altra parola. Il motore non determina le abilità/classi sul server in base al nome del personaggio.
  • Se richiesto, un type o un array piatto significa almeno una cosa dall'elenco. Un array di gruppi significa: hai bisogno di almeno una cosa da CIASCUN gruppo. Ad esempio, [cuoio, doghe] richiede pelle E un bastone. Si tratta di un insieme di alternative e non di un obbligo di indossare l'intero guardaroba elencato.
  • Qualsiasi oggetto indossato da Proibito esclude il personaggio da questa regola, anche se vengono soddisfatti quelli richiesti. La pelle più una catena vietata non supera la regola della pelle. Altre regole continuano a essere testate.
  • Vengono conteggiati solo gli oggetti caricati indossati sugli strati 1..24 ad eccezione dello zaino 21. Il contenuto dello zaino/baule, della montatura 25, del caricatore 26..28 e della sponda 29 non è considerato abbigliamento. Confronta graphic/type; Le cose serial, nome e hue non vengono utilizzate qui.
  • L'elenco non corrisponde senza l'attrezzatura adeguata caricata. L'assenza di un articolo proibito nei dati locali non dimostra la sua assenza sul server se il server non ha ancora inviato l'apparecchiatura. Il client non indovina i dati nascosti.
  • Le regole appartengono a uno script runtime, comprese le sue funzioni e Include; non vengono trasferiti ad altri lanci indipendenti e non vengono salvati nel profilo. Quando si ricomincia, definirli nuovamente, ad esempio mediante la procedura di configurazione generale. Un SetClassMask ripetuto sostituisce la regola con lo stesso nome, solo dopo che i nuovi dati sono stati completamente verificati.
  • Gli array vengono copiati durante la registrazione. La modifica dell'array originale non cambia la regola: ripeti SetClassMask. Le regole di corrispondenza multiple vengono risolte in base all'ordine dei nomi in classMask. Non esistono tabelle standard per l'abbigliamento del server.
  • Sono supportati gli argomenti posizionali 1..9. Puoi saltare la coda; per impostare classMask devono essere passati i primi sei argomenti. Utilizza il nome var per vedere il significato di ciascuna posizione.
  • Viene selezionato un bersaglio e l'attacco viene inviato una volta. Questo non è un ciclo di combattimento automatico. Senza classMask il filtro dell'attrezzatura e la lettura degli articoli non vengono eseguiti.
  • Prima i filtri generali, poi la priorità da sinistra a destra, poi quella più vicina. neighbor=false mantiene ancora la priorità della classe, ma all'interno della prima classe corrispondente seleziona il primo mobile nell'elenco dei client.
  • Il vecchio tentativo di cercare una sottostringa in un nome/titolo è stato sostituito dalle regole dell'equipaggiamento. Sposta tali script in un SetClassMask esplicito; Il nome del personaggio non lo identifica più come una classe specifica.

Script C# autonomi

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

Esempio semplice

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

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

var result = UO.AttackNearest(5, 5);
UO.Print("AttackNearest: " + Convert.ToString(result));

1. Nemico più vicino in cinque celle: forma breve - scrittura diretta

Parametri e flusso di esecuzione:

  • body=-1, maxZ=FindVertical(), più vicino=true, colore=-1, classMask disabilitato, aliveOnly=false, visibleOnly=false. Per essere sicuri di escludere le persone morte, utilizza il modulo completo sottostante.
var enemy = UO.AttackNearest(5, 5);
if (Truth(enemy == 0))
{
    return null;
}
UO.AddObject("combat_target", enemy);

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

2. Solo dati corpi e stessa altezza: tutte le bandiere senza classi - funzione script

Parametri e flusso di esecuzione:

  • maxZ=0 è utile per confronti rigorosi di altezza, ma potrebbe tagliare il bersaglio sul gradino. visibleOnly non controlla il muro. Tutti e nove gli argomenti sono firmati; restituisce ID, non true.
return  RunScenario();
 object? RunScenario()
{
    var status = "5|6";
    var radius = 8;
    var bodies = "0x0190|0x0191";
    var heightTolerance = 0;
    dynamic chooseNearest = true;
    var bodyHue = -1;
    var equipmentClasses = -1;
    dynamic requireAlive = true;
    dynamic requireVisible = true;
    var enemy = UO.AttackNearest(status, radius, bodies, heightTolerance, chooseNearest, bodyHue, equipmentClasses, requireAlive, requireVisible);
    if (Truth(enemy != 0))
    {
        UO.AddObject("enemy_same_height", 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. I tuoi nomi, le tue cose e l'ordine di attacco: classe dello scenario

Parametri e flusso di esecuzione:

  • DTMH viene selezionato per primo; solo se non ci sono DTMH - pesanti adatti, allora cacciatore. DTMH sulle celle 10 ha la priorità su quelle pesanti sulle celle 2. Per invertire l'ordine, cambiare la riga classMask. Dei due DTMH viene selezionato quello più vicino.
  • Gear è una funzione utente completamente ridotta C#, non un comando separato UO. I due array in Gear(leather, staves) formano due gruppi obbligatori. L'aggiunta di una tipologia alla pelle amplia le alternative; non richiede di indossare due articoli in pelle.
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 leather = Gear(0x13C4, 0x13C7);
        var staves = Gear(0x0DF0, 0x0E81);
        var chain = Gear(0x13BF, 0x13C0);
        var plate = Gear(0x1415, 0x1411);
        var bows = Gear(0x13B2, 0x0F50);
        UO.SetClassMask("DTMH", Gear(leather, staves), chain);
        UO.SetClassMask("охотник", bows);
        UO.SetClassMask("тяжёлый", plate);
        var notoriety = "5|6";
        var distance = 12;
        var body = -1;
        var maxZ = 8;
        dynamic nearest = true;
        var color = -1;
        var classMask = "DTMH|тяжёлый|охотник";
        dynamic aliveOnly = true;
        dynamic visibleOnly = true;
        var enemy = UO.AttackNearest(notoriety, distance, body, maxZ, nearest, color, classMask, aliveOnly, visibleOnly);
        if (Truth(enemy == 0))
        {
            UO.Print("No matching enemy; no attack sent");
            return null;
        }

        UO.AddObject("selected_enemy", enemy);
        return null;
    }

    dynamic Gear(params dynamic[] values)
    {
        return values;
    }

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

4. più vicino=false: il primo nell'elenco, non il più lontano - script diretto

Parametri e flusso di esecuzione:

  • 10 è il raggio, 4 è la differenza Z consentita, entrambi -1 dopo il colore di disabilitazione della bandiera e classMask. L'ordine dell'elenco dei clienti non è garantito tra gli aggiornamenti mondiali. Per una prossimità prevedibile, utilizzare true.
dynamic sortByDistance = false;
var target = UO.AttackNearest(5, 10, -1, 4, sortByDistance, -1, -1, true, true);
if (Truth(target == 0))
{
    return null;
}
UO.AddObject("current_enemy", target);

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

5. Riordina gruppi utenti - Funzione script

Parametri e flusso di esecuzione:

  • Cambia solo l'ordine delle etichette: non è necessario aggiungere nuove tabelle o nomi di abbigliamento al cliente. Per evitare il fallback su uno pesante, rimuovilo dalla priorità.
return  RunScenario();
 object? RunScenario()
{
    var leather = Gear(0x13C4, 0x13C7);
    var staves = Gear(0x0DF0, 0x0E81);
    var chain = Gear(0x13BF, 0x13C0);
    var plate = Gear(0x1415, 0x1411);
    var bows = Gear(0x13B2, 0x0F50);
    UO.SetClassMask("DTMH", Gear(leather, staves), chain);
    UO.SetClassMask("охотник", bows);
    UO.SetClassMask("тяжёлый", plate);
    var priority = "охотник|DTMH|тяжёлый";
    var enemy = UO.AttackNearest(5, 12, -1, 8, true, -1, priority, true, true);
    if (Truth(enemy != 0))
    {
        UO.AddObject("priority_enemy", enemy);
    }

    return null;
}

dynamic Gear(params dynamic[] values)
{
    return values;
}

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.AttackNearest(notoriety) — UO.AttackNearest(Any)

Parametri: notoriety (Any)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

values => new InjectionValue(CompactAttackNearest(values))

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

Parametri: notoriety (Any), distance (Any)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

values => new InjectionValue(CompactAttackNearest(values))

UO.AttackNearest(notoriety, distance, body) — UO.AttackNearest(Any,Any,Any)

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

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

values => new InjectionValue(CompactAttackNearest(values))

UO.AttackNearest(notoriety, distance, body, maxZ) — UO.AttackNearest(Any,Any,Any,Any)

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

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

values => new InjectionValue(CompactAttackNearest(values))

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

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

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

values => new InjectionValue(CompactAttackNearest(values))

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

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

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

values => new InjectionValue(CompactAttackNearest(values))

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

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

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

values => new InjectionValue(CompactAttackNearest(values))

UO.AttackNearest(notoriety, distance, body, maxZ, nearest, color, classMask, aliveOnly) — UO.AttackNearest(Any,Any,Any,Any,Any,Any,Any,Any)

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

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

values => new InjectionValue(CompactAttackNearest(values))

UO.AttackNearest(notoriety, distance, body, maxZ, nearest, color, classMask, aliveOnly, visibleOnly) — UO.AttackNearest(Any,Any,Any,Any,Any,Any,Any,Any,Any)

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

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

values => new InjectionValue(CompactAttackNearest(values))

UO.BandageSelf

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

Firme C#

void UO.BandageSelf();

Posiziona il personaggio come bersaglio UO.Wait e usa una benda di tipo 0x0E21 selezionata dallo zaino. L'operazione viene inviata dal client ed eseguita in modo asincrono dal server.

Parametri

Non ci sono parametri.

Valore restituito

void. Il metodo non restituisce lo stato del trattamento e non attende il completamento del bendaggio.

Comportamento

  • Runtime imposta l'obiettivo Self, quindi cerca nello zaino l'oggetto di tipo 0x0E21 più simile a qualsiasi hue e lo utilizza. Se la benda non viene trovata, la ricerca segnala l'accaduto al log di sistema; il risultato della ricerca non viene restituito allo script chiamante. La possibilità e il risultato del trattamento dipendono dallo stato del server del personaggio.

Script C# autonomi

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

Esempio semplice

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

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

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

1. Usa la benda trovata nello zaino su te stesso una volta. - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Usa la benda trovata nello zaino su te stesso una volta.
UO.BandageSelf();

2. Prima controlla la connessione, quindi invia l'azione; la chiamata non attende la fine del trattamento. - funzione di script

Parametri e flusso di esecuzione:

  • Prima controlla la connessione, quindi invia l'azione; la chiamata non attende la fine del trattamento.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Connected()))
    {
        UO.BandageSelf();
    }

    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. La procedura riporta solo l'utilizzo della benda e non riporta il successo del trattamento. - lezione di sceneggiatura

Parametri e flusso di esecuzione:

  • La procedura riporta solo l'utilizzo della benda e non riporta il successo del trattamento.
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()
    {
        ApplyBandage();
        return null;
    }

    void ApplyBandage()
    {
        UO.BandageSelf();
    }
}

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

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public void BandageSelf()

        {

            var foundBandages = FindType(new InjectionValue(0x0e21), new InjectionValue(0), new InjectionValue("my"));

            if (foundBandages != string.Empty)

            {

                WaitTargetSelf();

                UseObject(foundBandages);

            }

            else

                SystemMessage("No bandages found.");

        }

UO.ClearClassMask

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

Firme C#

int UO.ClearClassMask();
int UO.ClearClassMask(object? name);

Rimuove una regola dell'attrezzatura personalizzata o tutte le regole del runtime dello script corrente. Utile prima di riconfigurare i set o disabilitare la priorità temporanea.

Parametri

  • name — Nome opzionale passato a SetClassMask. Il caso non è importante. Senza argomenti, tutte le regole per questo runtime verranno eliminate. Questa non è una stringa di priorità: "mage|tank" non è consentito qui; rimuoverne uno alla volta o chiamare senza argomenti.

Valore restituito

int: numero di regole eliminate. Con il nome 1 significa cancellato, 0 - non esisteva una regola del genere. Senza argomenti, viene restituito 0..N, non un flag booleano. Pertanto, confronta il risultato complessivo con > 0 e non con true.

Comportamento

  • Non annulla un attacco già inviato e non ferma lo script. Non cambia l'equipaggiamento del personaggio.
  • Una volta cancellato, il nome resta sconosciuto al successivo AttackNearest. Rimuovilo anche da classMask o registralo nuovamente; un nome sconosciuto blocca tutta la selezione.
  • I tempi di esecuzione degli altri e le loro regole non vengono influenzati. Per una ricerca regolare senza classi, utilizzare classMask=-1 anziché il set di abbigliamento obbligatorio vuoto.

Script C# autonomi

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

Esempio semplice

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

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

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

1. Rimuovi la classe temporanea e utilizza quella rimanente: lo script diretto

Parametri e flusso di esecuzione:

  • La rimozione non cambia arma né pone fine al combattimento. Cambia solo un'ulteriore classificazione.
UO.SetClassMask("временный", 0x13B2);
UO.SetClassMask("основной", 0x1415);
UO.ClearClassMask("временный");
var enemy = UO.AttackNearest(5, 10, -1, 8, true, -1, "основной", true, true);
if (Truth(enemy != 0))
{
    UO.AddObject("main_enemy", enemy);
}

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

2. Ricrea tutte le regole per un'altra attività: funzione script

Parametri e flusso di esecuzione:

  • rimosse: numero di regole rimosse. Un nuovo set viene creato nello stesso runtime, senza riavviare il client.
return  RunScenario();
 object? RunScenario()
{
    UO.SetClassMask("старый_набор", 0x13B2);
    var removed = UO.ClearClassMask();
    UO.SetClassMask("новый_набор", 0x0F50);
    var enemy = UO.AttackNearest(5, 8, -1, 4, true, -1, "новый_набор", true, true);
    if (Truth(enemy != 0))
    {
        UO.AddObject("new_enemy", 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. Ripristina le regole e vai al normale obiettivo immediato: classe scenario

Parametri e flusso di esecuzione:

  • Non passare il nome remoto: il risultato sarebbe 0. -1 disabilita solo gli indumenti; gli altri filtri continuano a funzionare.
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.SetClassMask("по_одежде", 0x13C4);
        UO.ClearClassMask();
        var classes = -1;
        var enemy = UO.AttackNearest(5, 5, -1, 4, true, -1, classes, true, true);
        if (Truth(enemy != 0))
        {
            UO.AddObject("enemy_without_classes", 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;
}

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

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

args => new InjectionValue(ClearClassMask(null))

UO.ClearClassMask(name) — UO.ClearClassMask(Any)

Parametri: name (Any)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

args => new InjectionValue(ClearClassMask(ReadClassName(args[0])))

UO.GetAbilityID

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

Firme C#

int UO.GetAbilityID(object? abilityName);

Risolve il nome dell'abilità dell'arma o la stringa numerica nella directory del client ID.

Parametri

  • abilityName - string: nome AbilityData, enum Nome abilità o decimale ID. Gli spazi/la punteggiatura vengono rimossi durante il confronto dei nomi e non fanno distinzione tra maiuscole e minuscole.

Valore restituito

int 1..AbilityData.Abilities.Length - abilità conosciuta; 0 è un nome sconosciuto, una stringa normalizzata vuota o un numero ID esterno alla directory.

Comportamento

  • ResolveClassicUOAbilityId prima analizza l'int decimale, quindi confronta la directory normalizzata e i nomi enum. Il comando non attiva l'abilità né verifica la compatibilità con l'arma corrente.

Script C# autonomi

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

Esempio semplice

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

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

var result = UO.GetAbilityID("Armor Ignore");
UO.Print("GetAbilityID: " + Convert.ToString(result));

1. Risolvi nome - script diretto

Parametri e flusso di esecuzione:

  • Il numero rappresenta il ID del catalogo, non l'uso dell'abilità.
var id = UO.GetAbilityID("Armor Ignore");
UO.Print(Convert.ToString(id));

2. Stringa numerica - Funzione script

Parametri e flusso di esecuzione:

  • La linea 1 attraversa il percorso numerico del risolutore.
return  RunScenario();
 object? RunScenario()
{
    var id = UO.GetAbilityID("1");
    UO.Print(Convert.ToString(id));
    return null;
}

3. Nome sconosciuto: classe di script

Parametri e flusso di esecuzione:

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

     public object? RunScenario()
    {
        var id = UO.GetAbilityID("unknown-example-ability");
        UO.Print(Convert.ToString(id));
        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.GetAbilityID(abilityName) — UO.GetAbilityID(String)

Parametri: abilityName (String)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int GetAbilityID(string abilityName) => bridge.ResolveAbility(abilityName);

UO.GetAbilityName

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

Firme C#

string UO.GetAbilityName(object? abilityId);

Restituisce il nome dell'abilità di un'arma dalla sua directory ID.

Parametri

  • abilityId - int: l'indicizzazione ID inizia con 1; il ponte dice AbilityData.Abilità[abilityId-1].

Valore restituito

string nome della directory. Per ID inferiore a 1 o maggiore della lunghezza della directory, viene restituita una stringa vuota.

Comportamento

  • La lettura è locale e non attiva l'abilità. ID del catalogo non significa che l'abilità sia presente nell'arma attuale.

Script C# autonomi

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

Esempio semplice

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

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

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

1. Nome: scrittura diretta

Parametri e flusso di esecuzione:

  • ID 1 corrisponde al primo elemento della directory.
var name = UO.GetAbilityName(1);
UO.Print(name);

2. Risoluzione inversa - funzione script

Parametri e flusso di esecuzione:

  • Il nome viene restituito in base a ID trovato dal risolutore.
return  RunScenario();
 object? RunScenario()
{
    var id = UO.GetAbilityID("Armor Ignore");
    if (Truth(id > 0))
    {
        UO.Print(UO.GetAbilityName(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. ID non valido: classe di script

Parametri e flusso di esecuzione:

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

     public object? RunScenario()
    {
        var name = UO.GetAbilityName(0);
        UO.Print(Convert.ToString(Len(name)));
        return null;
    }

    int Len(object? value) => Convert.ToString(value)?.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.GetAbilityName(abilityId) — UO.GetAbilityName(Integer)

Parametri: abilityId (Integer)

Risultato: string / String.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public string GetAbilityName(int abilityId) => bridge.GetAbilityName(abilityId);

UO.GetActiveAbility

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

Firme C#

dynamic UO.GetActiveAbility();

Legge il nome dell'abilità di combattimento attivata del tuo personaggio.

Parametri

Non ci sono parametri.

Valore restituito

string è il nome inglese dell'abilità attivata, ad esempio Armor Ignore. Stringa "0" se nessuna abilità è attivata o manca un personaggio. Questa non è un'abilità int 0, né un'abilità ID, né è una conferma di un colpo andato a segno.

Comportamento

  • Vengono letti i flag PrimaryAbility/SecondaryAbility del carattere corrente. Se entrambi sono attivi, viene scelta l'abilità primaria. Il contrassegno dell'attività viene rimosso dal numero prima che venga cercato il nome.
  • I dati vengono letti localmente; il getter stesso non attiva l'abilità e non consuma mana. Dopo l'attacco, il server può rimuovere l'attivazione.

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

1. Mostra abilità attiva - script diretto

Parametri e flusso di esecuzione:

  • Non ci sono argomenti; viene letto il carattere del client corrente.
  • Se non c'è attivazione viene stampata la stringa 0.
var name = UO.GetActiveAbility();
UO.Print(name);

2. Attiva un'abilità primaria solo se non ce n'è una attiva: funzione script

Parametri e flusso di esecuzione:

  • Il confronto viene effettuato con la stringa 0. UsePrimaryAbility viene chiamato separatamente.
  • Questa è una richiesta di attivazione, non la prova di un attacco riuscito. La disponibilità dipende dalle armi e dalle regole del server.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.GetActiveAbility() == "0"))
    {
        UO.UsePrimaryAbility();
    }

    return null;
}

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

3. Converti nome in ID Abilità - Classe di script

Parametri e flusso di esecuzione:

  • GetAbilityID riceve il nome restituito dal getter.
  • L'abilità ID non è l'arma o il personaggio serial. Innanzitutto è esclusa l’assenza di un’abilità attiva.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var name = UO.GetActiveAbility();
        if (Truth(name != "0"))
        {
            var id = UO.GetAbilityID(name);
            UO.Print("Ability ID: " + Convert.ToString(id));
        }

        return null;
    }

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

Implementazione del comando

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

UO.GetActiveAbility() — UO.GetActiveAbility()

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "getactiveability": return new InjectionValue(bridge.GetActiveAbility());

UO.GetWeaponAbilities

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

Firme C#

dynamic UO.GetWeaponAbilities();

Bridge legge Player.Abilities, applica il valore ((byte) e 0x7F), memorizza il positivo ID nell'ordine originale.

Parametri

Non ci sono parametri.

Valore restituito

Matrice di abilità int positive ID dell'arma corrente. La bandiera alta 0x80 viene rimossa; sono esclusi i valori zero. Senza Player: un array vuoto.

Comportamento

  • Bridge legge Player.Abilities, applica il valore ((byte) e 0x7F), memorizza il positivo ID nell'ordine originale. Restituisce il ID disponibile, non il fatto della modalità attiva e non i nomi.
  • Legge lo stato locale attuale. Non esiste alcun pacchetto, destinazione o aggiornamento automatico; le singole letture possono vedere stati diversi.

Script C# autonomi

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

Esempio semplice

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

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

object? result = UO.GetWeaponAbilities();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Bridge legge Player.Abilities, applica il valore ((byte) e 0x7F), memorizza il positivo ID nell'ordine originale.
var abilities = UO.GetWeaponAbilities();
UO.Print(UO.GetArrayLength(abilities));

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • Bridge legge Player.Abilities, applica il valore ((byte) e 0x7F), memorizza il positivo ID nell'ordine originale. Restituisce il ID disponibile, non il fatto della modalità attiva e non i nomi.
return  RunScenario();
 object? RunScenario()
{
    var abilities = UO.GetWeaponAbilities();
    if (Truth(UO.GetArrayLength(abilities) > 0))
    {
        UO.Print(UO.GetAbilityName(abilities[0]));
    }

    return null;
}

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

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

  • Legge lo stato locale attuale. Non esiste alcun pacchetto, destinazione o aggiornamento automatico; le singole letture possono vedere stati diversi.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var before = UO.GetWeaponAbilities();
        UO.Wait(500);
        var after = UO.GetWeaponAbilities();
        UO.Print(before);
        UO.Print(after);
        return null;
    }
}

Implementazione del comando

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

UO.GetWeaponAbilities() — UO.GetWeaponAbilities()

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public InjectionValue GetWeaponAbilities() => new InjectionValue(

            (bridge.GetWeaponAbilities() ?? Array.Empty<int>()).Select(value => new InjectionValue(value)).ToArray());

UO.IsWarMode

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

Firme C#

int UO.IsWarMode(object? objID);

Controlla la posizione di combattimento mobile.

Parametri

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

Valore restituito

int 1 - caricato mobile ha l'attributo InWarMode. int 0 - manca l'attributo, l'oggetto non è mobile, sconosciuto o eliminato. Non ti dice chi il personaggio sta attaccando né attiva la modalità combattimento. La lettura della modalità straniera è limitata ai dati ricevuti dal server.

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

Comportamento

  • Viene letto il modello client locale; Non ci sono richieste al server, nessuna attesa o spostamento.
  • Il risultato si riferisce al momento della lettura. Dopo UO.Wait o altra azione, l'oggetto e i suoi flag potrebbero cambiare.
  • Non ti dice chi il personaggio sta attaccando né attiva la modalità combattimento. La lettura della modalità straniera è limitata ai dati ricevuti dal server.

Script C# autonomi

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

Esempio semplice

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

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

1. Controlla il tuo stato - script diretto

Parametri e flusso di esecuzione:

  • L'argomento self seleziona esplicitamente il suo carattere. stato - solo 1/0.
  • Non ti dice chi il personaggio sta attaccando né attiva la modalità combattimento. La lettura della modalità straniera è limitata ai dati ricevuti dal server.
var state = UO.IsWarMode("self");
if (Truth(state))
{
    UO.Print("Combat stance is active");
}
else
{
    UO.Print("Combat stance is inactive");
}

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

2. Controlla la funzione script mobile selezionata

Parametri e flusso di esecuzione:

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

    return null;
}

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

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

Parametri e flusso di esecuzione:

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

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

        return null;
    }

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

Implementazione del comando

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

UO.IsWarMode(objID) — UO.IsWarMode(Any)

Parametri: objID (Any)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "iswarmode": return new InjectionValue(arguments.Length > 0 ? bridge.IsWarMode(Arg(0)) : WarMode());

UO.LastAttack

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

Firme C#

dynamic UO.LastAttack();

Legge serial dell'ultimo bersaglio dell'attacco.

Parametri

Non ci sono parametri.

Valore restituito

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

Comportamento

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

Script C# autonomi

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

Esempio semplice

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

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

object? result = UO.LastAttack();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Legge serial dell'ultimo bersaglio dell'attacco.
var id = UO.LastAttack();
UO.Print(Hex(id));

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

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • Sorgente campo: bridge.LastAttack. Il comando non seleziona, utilizza o attacca l'oggetto.
return  RunScenario();
 object? RunScenario()
{
    var id = UO.LastAttack();
    if (Truth(id != 0) && Truth(UO.Exists(id)))
    {
        UO.Print(UO.GetName(id));
    }

    return null;
}

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

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

  • Legge lo stato locale attuale. Non esiste alcun pacchetto, destinazione o aggiornamento automatico; le singole letture possono vedere stati diversi.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var before = UO.LastAttack();
        UO.Wait(500);
        var after = UO.LastAttack();
        UO.Print(before = after);
        return null;
    }
}

Implementazione del comando

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

UO.LastAttack() — UO.LastAttack()

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "lastattack":

                case "wartargetid": return new InjectionValue(bridge.LastAttack);

UO.SetClassMask

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

Firme C#

int UO.SetClassMask(object? name, object? required);
int UO.SetClassMask(object? name, object? required, object? forbidden);

Crea o sostituisce una classe di equipaggiamento personalizzata per classMask in UO.AttackNearest. Scegli un nome e cose graphic/type; i titoli di lavoro incorporati non sono richiesti.

Parametri

  • name — Una stringa non vuota con il tuo nome, ad esempio "DTMH", "my_group", "archer_with_shield". Le maiuscole e minuscole non sono importanti, gli spazi attorno ai bordi vengono rimossi. | , ; proibito: questi sono separatori di priorità. any/all/-1 sono riservati per disabilitare il filtro.
  • required — Uno type, una serie piatta di alternative o una serie di gruppi obbligatori. Ogni gruppo è type o un array piatto. Hai bisogno di almeno una cosa da ciascun gruppo; i gruppi obbligatori vuoti non sono consentiti. Ogni type è una int/stringa numerica/esadecimale 1..65534. Non è accettata la nidificazione più profonda di una serie di gruppi. Queste sono cose graphic, non caratteri serial e non body.
  • forbidden — Opzionale type o array semplice di tipi illegali. Per impostazione predefinita, non sono presenti articoli proibiti; è consentito anche un array vuoto. Se viene indossato uno di questi oggetti, la regola non corrisponde. Gli stessi confini 1..65534; -1/any non sono accettati qui. È impossibile vietare completamente tutte le alternative a un gruppo obbligatorio.

Valore restituito

int 1 - la regola è stata controllata e registrata. Un tipo/nome non valido/gruppo richiesto vuoto/incoerenza provoca un errore di script, che può essere rilevato da try/CATCH; resta la regola precedente. Non restituisce serial né trova caratteri e non avvia un attacco.

Comportamento

  • Il nome è un'etichetta personalizzata, non una professione di server. Puoi chiamare la regola DTMH, my_group o qualsiasi altra parola. Il motore non determina le abilità/classi sul server in base al nome del personaggio.
  • Se richiesto, un type o un array piatto significa almeno una cosa dall'elenco. Un array di gruppi significa: hai bisogno di almeno una cosa da CIASCUN gruppo. Ad esempio, [cuoio, doghe] richiede pelle E un bastone. Si tratta di un insieme di alternative e non di un obbligo di indossare l'intero guardaroba elencato.
  • Qualsiasi oggetto indossato da Proibito esclude il personaggio da questa regola, anche se vengono soddisfatti quelli richiesti. La pelle più una catena vietata non supera la regola della pelle. Altre regole continuano a essere testate.
  • Vengono conteggiati solo gli oggetti caricati indossati sugli strati 1..24 ad eccezione dello zaino 21. Il contenuto dello zaino/baule, della montatura 25, del caricatore 26..28 e della sponda 29 non è considerato abbigliamento. Confronta graphic/type; Le cose serial, nome e hue non vengono utilizzate qui.
  • L'elenco non corrisponde senza l'attrezzatura adeguata caricata. L'assenza di un articolo proibito nei dati locali non dimostra la sua assenza sul server se il server non ha ancora inviato l'apparecchiatura. Il client non indovina i dati nascosti.
  • Le regole appartengono a uno script runtime, comprese le sue funzioni e Include; non vengono trasferiti ad altri lanci indipendenti e non vengono salvati nel profilo. Quando si ricomincia, definirli nuovamente, ad esempio mediante la procedura di configurazione generale. Un SetClassMask ripetuto sostituisce la regola con lo stesso nome, solo dopo che i nuovi dati sono stati completamente verificati.
  • Gli array vengono copiati durante la registrazione. La modifica dell'array originale non cambia la regola: ripeti SetClassMask. Le regole di corrispondenza multiple vengono risolte in base all'ordine dei nomi in classMask. Non esistono tabelle standard per l'abbigliamento del server.

Script C# autonomi

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

Esempio semplice

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

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

var result = UO.SetClassMask("simple_sword", 0x0F5E);
UO.Print("SetClassMask: " + Convert.ToString(result));

1. DTMH: la tua pelle senza catena - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • DTMH - solo il tuo nome. I valori in myLeather/forbiddenChain sono esempi: sostituisci/integra con il reale graphic del tuo server. Una lista piatta significa OR, non un set completo.
var myLeather = Gear(0x13C4, 0x13C7);
var forbiddenChain = Gear(0x13BF, 0x13C0);
UO.SetClassMask("DTMH", myLeather, forbiddenChain);
var enemy = UO.AttackNearest(5, 10, -1, 8, true, -1, "DTMH", true, true);
if (Truth(enemy != 0))
{
    UO.AddObject("leather_enemy", enemy);
}

dynamic Gear(params dynamic[] values)
{
    return values;
}

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

2. I tuoi nomi, le tue cose e l'ordine di attacco: una funzione della sceneggiatura

Parametri e flusso di esecuzione:

  • DTMH viene selezionato per primo; solo se non ci sono DTMH - pesanti adatti, allora cacciatore. DTMH sulle celle 10 ha la priorità su quelle pesanti sulle celle 2. Per invertire l'ordine, cambiare la riga classMask. Dei due DTMH viene selezionato quello più vicino.
  • Gear è una funzione utente completamente ridotta C#, non un comando separato UO. I due array in Gear(leather, staves) formano due gruppi obbligatori. L'aggiunta di una tipologia alla pelle amplia le alternative; non richiede di indossare due articoli in pelle.
return  RunScenario();
 object? RunScenario()
{
    var leather = Gear(0x13C4, 0x13C7);
    var staves = Gear(0x0DF0, 0x0E81);
    var chain = Gear(0x13BF, 0x13C0);
    var plate = Gear(0x1415, 0x1411);
    var bows = Gear(0x13B2, 0x0F50);
    UO.SetClassMask("DTMH", Gear(leather, staves), chain);
    UO.SetClassMask("охотник", bows);
    UO.SetClassMask("тяжёлый", plate);
    var notoriety = "5|6";
    var distance = 12;
    var body = -1;
    var maxZ = 8;
    dynamic nearest = true;
    var color = -1;
    var classMask = "DTMH|тяжёлый|охотник";
    dynamic aliveOnly = true;
    dynamic visibleOnly = true;
    var enemy = UO.AttackNearest(notoriety, distance, body, maxZ, nearest, color, classMask, aliveOnly, visibleOnly);
    if (Truth(enemy == 0))
    {
        UO.Print("No matching enemy; no attack sent");
        return null;
    }

    UO.AddObject("selected_enemy", enemy);
    return null;
}

dynamic Gear(params dynamic[] values)
{
    return values;
}

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

3. Set completo di tipi richiesti tramite dichiarazione di variabile - classe di script

Parametri e flusso di esecuzione:

  • dichiarando la variabile request[1] si creano due elementi con indici 0 e 1. I due gruppi nidificati richiedono torso E arma; piatto [torsoType,weaponType] significherebbe torso O arma.
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[] required = new dynamic[checked((int)(1) + 1)];
        dynamic[] torso = new dynamic[checked((int)(0) + 1)];
        dynamic[] weapon = new dynamic[checked((int)(0) + 1)];
        torso[0] = 0x13C4;
        weapon[0] = 0x0DF0;
        required[0] = torso;
        required[1] = weapon;
        UO.SetClassMask("мой_комплект", required);
        var enemy = UO.AttackNearest(5, 6, -1, 4, true, -1, "мой_комплект", true, true);
        if (Truth(enemy != 0))
        {
            UO.AddObject("outfit_enemy", 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;
}

4. Cambiare i vestiti secondo la regola prima del prossimo attacco - copione diretto

Parametri e flusso di esecuzione:

  • La nuova registrazione sostituisce una copia della regola. Il vecchio nome rimane lo stesso, quindi non è necessario riscrivere la riga di priorità.
dynamic[] allowed = new dynamic[checked((int)(0) + 1)];
allowed[0] = 0x13B2;
UO.SetClassMask("приоритетный", allowed);
allowed[0] = 0x0F50;
UO.SetClassMask("приоритетный", allowed);
var enemy = UO.AttackNearest(5, 10, -1, 8, true, -1, "приоритетный", true, true);
if (Truth(enemy != 0))
{
    UO.AddObject("updated_outfit", enemy);
}

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.SetClassMask(name, required) — UO.SetClassMask(Any,Any)

Parametri: name (Any), required (Any)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

args => new InjectionValue(SetClassMask(args))

UO.SetClassMask(name, required, forbidden) — UO.SetClassMask(Any,Any,Any)

Parametri: name (Any), required (Any), forbidden (Any)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

args => new InjectionValue(SetClassMask(args))

UO.SetWarMode

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

Firme C#

void UO.SetWarMode(object? value);

Richiede la modalità di combattimento o pacifica del personaggio.

Parametri

  • value - 0 - modalità pacifica; qualsiasi numero intero diverso da zero è la modalità combattimento.

Valore restituito

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

Comportamento

  • WarMode passa la modalità a GameActions.ToggleWarMode: 0 disabilita, qualsiasi valore diverso da zero abilita. Senza Player non c'è azione.
  • Bridge invia la richiesta sullo streaming del gioco. Si applicano le regole del server; Non è prevista l'attesa di conferma.

Script C# autonomi

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

Esempio semplice

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

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

UO.Print("Calling UO.SetWarMode");
UO.SetWarMode(1);

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Richiede la modalità di combattimento o pacifica del personaggio.
UO.SetWarMode(1);

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • WarMode passa la modalità a GameActions.ToggleWarMode: 0 disabilita, qualsiasi valore diverso da zero abilita. Senza Player non c'è azione.
return  RunScenario();
 object? RunScenario()
{
    UO.SetWarMode(0);
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

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

     public object? RunScenario()
    {
        ApplyMode(1);
        return null;
    }

    void ApplyMode(dynamic mode)
    {
        UO.SetWarMode(mode);
    }
}

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.SetWarMode(value) — UO.SetWarMode(Any)

Parametri: value (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "setwarmode": WarMode(Arg(0)); return InjectionValue.Unit;

UO.Specmove

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

Firme C#

void UO.Specmove(object? direction);
void UO.Specmove(object? direction, object? running);

Invia una richiesta di passaggio direttamente al bridge.

Parametri

  • direction — int; direzione & 7 daët 0..7 N,NE,E,SE,S,SW,W,NW.
  • running - Flag numerico opzionale int: 0/none - camminare, diverso da zero - correre.

Valore restituito

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

Comportamento

  • ExecuteLegacyManualAlias chiama bridge.Step(direzione & 7, esecuzione != 0) e scarta tutto il codice risultato 0/2/3/4/5/7; void ritorna all'esterno. Questo è un passo/giro, non un percorso. Viene mantenuta l'attesa compresa tra Step e 10000 ms, ma lo script non riceve un codice di riconoscimento, errore o timeout.
  • Il ramo non soddisfa le condizioni di runtime MoveCheckStamina/MoveExitOnDisconnect/MoveOpenDoor da UO.Step. Bridge/Player.Walk stesso e il server continuano a controllare il movimento.
  • QueueStep sullo streaming del gioco controlla il giocatore, la connessione, la direzione, la coda, il tempo e il traffico locale. Prima di Player.Walk, ciascuna chiamata registra separatamente le generazioni Conferma/Nega della sua sequenza e del Walker; quindi restituisce Risultato insieme a questa istantanea. Step e in sospeso StepControlled controlla solo questa coppia memorizzata, non i campi comuni della richiesta successiva; il giocatore/Walker sostitutivo conclude l'attesa con un rifiuto generale. La conferma di un altro comando regolare non conferma questo passaggio. La rotazione senza movimento resta un caso a parte.

Script C# autonomi

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

Esempio semplice

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

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

UO.Print("Calling UO.Specmove");
UO.Specmove(0);

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Invia una richiesta di passaggio direttamente al bridge.
UO.Specmove(0);

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • ExecuteLegacyManualAlias chiama bridge.Step(direction&7,running!=0), quindi scarta il 1/0 restituito. Questo è un passo, non un percorso verso una coordinata.
return  RunScenario();
 object? RunScenario()
{
    UO.Specmove(2, 1);
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

  • Il ramo non soddisfa le condizioni di runtime MoveCheckStamina/MoveExitOnDisconnect/MoveOpenDoor da UO.Step. Bridge/Player.Walk stesso e il server continuano a controllare il movimento.

Velocità di guida standard

Intervallo minimo di passo: camminare - camminare 400 ms, correre 200 ms; cavalcare - camminare 200 ms, correre 100 ms.

Questi sono limiti client standard, non impostazioni definite automaticamente per il tuo shard. La velocità del server e le modalità di volo vengono conteggiate separatamente. I timer degli script possono rallentare il movimento, ma non riducono questi limiti.

Passi, percorsi, Follow, controlli mouse/tasti e mappa utilizzano la coda condivisa del personaggio. La sostituzione del percorso, la svolta o la regolazione della posizione da parte del server non annulla la pausa rimanente dopo la richiesta del passo. Dopo il ritardo, non vi è alcuna raffica veloce per compensare i fotogrammi persi. L'attesa di conferme, gli ostacoli e la scarsa comunicazione possono rallentare il movimento.

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

     public object? RunScenario()
    {
        var before = UO.GetX();
        UO.Specmove(2, 0);
        UO.Wait(500);
        UO.Print(UO.GetX() - before);
        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.Specmove(direction) — UO.Specmove(Any)

Parametri: direction (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "specmove": bridge.Step(Arg(0) & 7, arguments.Length > 1 && Arg(1) != 0); break;

UO.Specmove(direction, running) — UO.Specmove(Any,Any)

Parametri: direction (Any), running (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "specmove": bridge.Step(Arg(0) & 7, arguments.Length > 1 && Arg(1) != 0); break;

UO.UseAbility

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

Firme C#

int UO.UseAbility(object? abilityId);

Richiede l'abilità disponibile per l'arma attuale.

Parametri

  • abilityId — Nome dell'abilità o int ID 1..AbilityData.Abilities.Length. I nomi sono normalizzati: solo le lettere/numeri vengono memorizzati e confrontati in maiuscolo. Il testo numerico significa ID.

Valore restituito

Flag numerico int: 1 - ID corrisponde all'abilità primaria/secondaria del giocatore corrente e viene chiamato il corrispondente GameActions; 0 - nessun giocatore, sconosciuto ID/nome o abilità non appartiene all'arma corrente.

Comportamento

  • La forma stringa utilizza ResolveAbility; numerico immediatamente ponte.UseAbility. Bridge maschera 0x80 da due abilità attuali e abbina ID, quindi chiama UsePrimaryAbility o UseSecondaryAbility.
  • Si tratta dell'accettazione di una richiesta locale, non della conferma di un successo, di una spesa di mana o di un'attivazione da parte del server. I ID disponibili vengono letti GetWeaponAbilities, il nome attivo è GetActiveAbility.
  • GameActions attiva/disattiva il bit di selezione dell'abilità 0x80. Un'abilità già selezionata invia ID 0 e la deseleziona; in caso contrario, entrambi i bit di selezione vengono cancellati, viene inviato il ID selezionato, quindi il suo bit viene impostato localmente. Pertanto, richiamarlo nuovamente potrebbe disattivare l'abilità. Una modifica locale non significa un successo o una conferma del server.

Script C# autonomi

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

Esempio semplice

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

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

var result = UO.UseAbility("Armor Ignore");
UO.Print("UseAbility: " + Convert.ToString(result));

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Richiede l'abilità disponibile per l'arma attuale.
UO.Print(UO.UseAbility("Armor Ignore"));

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • La forma stringa utilizza ResolveAbility; numerico immediatamente ponte.UseAbility. Bridge maschera 0x80 da due abilità attuali e abbina ID, quindi chiama UsePrimaryAbility o UseSecondaryAbility.
return  RunScenario();
 object? RunScenario()
{
    var abilities = UO.GetWeaponAbilities();
    if (Truth(UO.GetArrayLength(abilities) > 0))
    {
        UO.Print(UO.UseAbility(abilities[0]));
    }

    return null;
}

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

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

  • Si tratta dell'accettazione di una richiesta locale, non della conferma di un successo, di una spesa di mana o di un'attivazione da parte del server. I ID disponibili vengono letti GetWeaponAbilities, il nome attivo è GetActiveAbility.
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.GetAbilityID("Armor Ignore");
        if (Truth(id > 0))
        {
            var accepted = UO.UseAbility(id);
            UO.Print(accepted);
            UO.Print(UO.GetActiveAbility());
        }

        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.UseAbility(abilityId) — UO.UseAbility(Integer)

Parametri: abilityId (Integer/String)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int UseAbility(int abilityId) => bridge.UseAbility(abilityId);

UO.UseAbility(abilityId) — UO.UseAbility(String)

Parametri: abilityId (Integer/String)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int UseAbility(string abilityName)

        {

            int abilityId = bridge.ResolveAbility(abilityName);

            return abilityId > 0 ? bridge.UseAbility(abilityId) : 0;

        }

UO.UsePrimaryAbility

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

Firme C#

void UO.UsePrimaryAbility();

Evoca l'abilità primaria dell'arma.

Parametri

Non ci sono parametri.

Valore restituito

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

Comportamento

  • UsePrimaryAbility trasmette GameActions.UsePrimaryAbility(_world) tramite Invoke. Non viene restituito alcun segno di accettazione; l'abilità attiva viene controllata separatamente.
  • Negli esempi, UO.Wait specifica solo una pausa nello script; la fine della pausa non dimostra che il server abbia completato la richiesta.
  • GameActions attiva/disattiva il bit di selezione dell'abilità 0x80. Un'abilità già selezionata invia ID 0 e la deseleziona; in caso contrario, entrambi i bit di selezione vengono cancellati, viene inviato il ID selezionato, quindi il suo bit viene impostato localmente. Pertanto, richiamarlo nuovamente potrebbe disattivare l'abilità. Una modifica locale non significa un successo o una conferma del server.

Script C# autonomi

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

Esempio semplice

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

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

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Evoca l'abilità primaria dell'arma.
UO.UsePrimaryAbility();

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • UsePrimaryAbility trasmette GameActions.UsePrimaryAbility(_world) tramite Invoke. Non viene restituito alcun segno di accettazione; l'abilità attiva viene controllata separatamente.
return  RunScenario();
 object? RunScenario()
{
    UO.Print(UO.GetWeaponAbilities());
    UO.UsePrimaryAbility();
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

  • Negli esempi, UO.Wait specifica solo una pausa nello script; la fine della pausa non dimostra che il server abbia completato la richiesta.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        UO.UsePrimaryAbility();
        UO.Print(UO.GetActiveAbility());
        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.UsePrimaryAbility() — UO.UsePrimaryAbility()

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "useprimaryability": bridge.UsePrimaryAbility(); return InjectionValue.Unit;

UO.UseSecondaryAbility

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

Firme C#

void UO.UseSecondaryAbility();

Evoca un'abilità aggiuntiva dell'arma.

Parametri

Non ci sono parametri.

Valore restituito

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

Comportamento

  • UseSecondaryAbility trasmette GameActions.UseSecondaryAbility(_world) tramite Invoke. Non viene restituito alcun segno di accettazione; l'abilità attiva viene controllata separatamente.
  • Negli esempi, UO.Wait specifica solo una pausa nello script; la fine della pausa non dimostra che il server abbia completato la richiesta.
  • GameActions attiva/disattiva il bit di selezione dell'abilità 0x80. Un'abilità già selezionata invia ID 0 e la deseleziona; in caso contrario, entrambi i bit di selezione vengono cancellati, viene inviato il ID selezionato, quindi il suo bit viene impostato localmente. Pertanto, richiamarlo nuovamente potrebbe disattivare l'abilità. Una modifica locale non significa un successo o una conferma del server.

Script C# autonomi

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

Esempio semplice

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

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

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Evoca un'abilità aggiuntiva dell'arma.
UO.UseSecondaryAbility();

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • UseSecondaryAbility trasmette GameActions.UseSecondaryAbility(_world) tramite Invoke. Non viene restituito alcun segno di accettazione; l'abilità attiva viene controllata separatamente.
return  RunScenario();
 object? RunScenario()
{
    UO.Print(UO.GetWeaponAbilities());
    UO.UseSecondaryAbility();
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

  • Negli esempi, UO.Wait specifica solo una pausa nello script; la fine della pausa non dimostra che il server abbia completato la richiesta.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        UO.UseSecondaryAbility();
        UO.Print(UO.GetActiveAbility());
        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.UseSecondaryAbility() — UO.UseSecondaryAbility()

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "usesecondaryability": bridge.UseSecondaryAbility(); return InjectionValue.Unit;

UO.WarMode

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

Firme C#

int UO.WarMode();
void UO.WarMode(object? mode);

Legge o interroga la modalità di combattimento del personaggio.

Parametri

  • mode - Opzionale int: 0 disabilita, qualsiasi valore diverso da zero abilita. Il modulo senza argomenti legge solo.

Valore restituito

Nessun argomento Flag numerico int: 1 - giocatore attuale in modalità combattimento, 0 - modalità pacifica/nessun giocatore. Con la modalità - null non vi è alcun risultato.

Comportamento

  • WarMode() legge Player.InWarMode localmente. WarMode(mode) richiama GameActions.ToggleWarMode con la modalità selezionata; senza Player la richiesta non viene eseguita.
  • Non assegnare il risultato di un modulo con un argomento a una variabile. La rilettura immediata non costituisce una conferma online.

Script C# autonomi

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

Esempio semplice

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

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

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Legge o interroga la modalità di combattimento del personaggio.
var active = UO.WarMode();
UO.Print(active);

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • WarMode() legge Player.InWarMode localmente. WarMode(mode) richiama GameActions.ToggleWarMode con la modalità selezionata; senza Player la richiesta non viene eseguita.
return  RunScenario();
 object? RunScenario()
{
    UO.WarMode(1);
    UO.Wait(250);
    UO.Print(UO.WarMode());
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

  • Non assegnare il risultato di un modulo con un argomento a una variabile. La rilettura immediata non costituisce una conferma online.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var before = UO.WarMode();
        UO.WarMode(0);
        UO.Print(before);
        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.WarMode() — UO.WarMode()

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

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

UO.WarMode(mode) — UO.WarMode(Integer)

Parametri: mode (Integer)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public void WarMode(int mode) => bridge.WarMode(mode);

UO.WarTargetID

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

Firme C#

dynamic UO.WarTargetID();

Legge serial dell'ultimo bersaglio dell'attacco.

Parametri

Non ci sono parametri.

Valore restituito

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

Comportamento

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

Script C# autonomi

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

Esempio semplice

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

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

object? result = UO.WarTargetID();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Legge serial dell'ultimo bersaglio dell'attacco.
var id = UO.WarTargetID();
UO.Print(Hex(id));

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

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • Sorgente campo: bridge.LastAttack. Il comando non seleziona, utilizza o attacca l'oggetto.
return  RunScenario();
 object? RunScenario()
{
    var id = UO.WarTargetID();
    if (Truth(id != 0) && Truth(UO.Exists(id)))
    {
        UO.Print(UO.GetName(id));
    }

    return null;
}

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

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

  • Legge lo stato locale attuale. Non esiste alcun pacchetto, destinazione o aggiornamento automatico; le singole letture possono vedere stati diversi.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var before = UO.WarTargetID();
        UO.Wait(500);
        var after = UO.WarTargetID();
        UO.Print(before = after);
        return null;
    }
}

Implementazione del comando

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

UO.WarTargetID() — UO.WarTargetID()

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "lastattack":

                case "wartargetid": return new InjectionValue(bridge.LastAttack);

ClassicUO — Bad Newbie & C# Scripts IDE

ClassicUO — Bad Newbie & C# Scripts IDE

Clone this wiki locally