Skip to content

IT UO Topic magic

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

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

Magia

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

Incantesimi, abilità e movimento con la magia. Per un'azione mirata, fissare in anticipo l'obiettivo e verificare le condizioni di applicazione.

Incantesimi: tutti i nomi e i numeri

Apri catalogo completo ed esempi

Sezioni

Argomento Comandi e spiegazioni
Cast UO.Cast
CastToObject UO.CastToObject
CastAbility UO.CastAbility
Active Spell Ability UO.IsActiveSpellAbility
Spell Timers UO.TicksSpell

Tutti i comandi del tema

Colata

UO.Cast · UO.CastToObject · UO.CastAbility · UO.IsActiveSpellAbility · UO.TicksSpell

Viaggio

UO.AddRecall · UO.AddGate

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

Parametri, risultato e tutti gli scenari

UO.CancelWaitTarget();
if (Truth(UO.Cast("Cure")))
{
    UO.Print("Choose the character with the spell cursor");
}
else
{
    UO.Print("Cure request rejected");
}

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

UO.CastToObject

Parametri, risultato e tutti gli scenari

var accepted = UO.CastToObject("Heal", "self");
UO.Print(Convert.ToString(accepted));

Riferimento completo dei comandi

UO.AddGate

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

Firme C#

void UO.AddGate(object? bookSerial);

Parametri

  • bookSerial è un valore identificativo che lo script compatibile salva come voce dell'elenco legacy. Al momento dell'esecuzione corrente, il valore viene serializzato in una stringa; Il comando non verifica l'esistenza di un oggetto nel mondo.

Valore restituito

void. Il team non conferma la disponibilità del libro o la creazione del portale di gioco.

Comportamento

  • Il valore viene aggiunto all'elenco AddGate dello stato di runtime corrente. In ClassicUO, questo elenco di compatibilità non attiva un'azione di gioco e non dispone di un getter pubblico documentato da leggere.

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.AddGate");
UO.AddGate("0x40012345");

1. Salva l'ID come dati legacy senza aprire il cancello. - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Salva l'ID come dati legacy senza aprire il cancello.
UO.AddGate("0x40012345");

2. Utilizza il valore della stringa passata a uno script compatibile. - funzione di script

Parametri e flusso di esecuzione:

  • Utilizza il valore della stringa passata a uno script compatibile.
return  RunScenario();
 object? RunScenario()
{
    var bookSerial = "0x40012345";
    UO.AddGate(bookSerial);
    return null;
}

3. Scrivere il valore nell'elenco di runtime AddGate. - lezione di sceneggiatura

Parametri e flusso di esecuzione:

  • Scrivere il valore nell'elenco di runtime AddGate.
  • La chiamata memorizza i dati di compatibilità; non usa il libro al mondo.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        RememberGateBook("0x40012345");
        return null;
    }

    void RememberGateBook(dynamic bookSerial)
    {
        UO.AddGate(bookSerial);
    }
}

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.AddGate(bookSerial) — UO.AddGate(Any)

Parametri: bookSerial (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "adddir":

                case "addfindlist":

                case "addgate":

                case "addrecall":

                case "addstep":

                    LegacyList(name).Add(string.Join("|", arguments.Select(value => value.ToString())));

                    break;

UO.AddRecall

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

Firme C#

void UO.AddRecall(object? bookSerial);

Parametri

  • bookSerial è un valore identificativo che lo script compatibile salva come voce dell'elenco legacy. Il runtime serializza il valore passato in una stringa.

Valore restituito

void. La chiamata non restituisce esito e non conferma la presenza del libro.

Comportamento

  • Il valore viene aggiunto all'elenco AddRecall dello stato di runtime corrente. In ClassicUO, questo stesso elenco di compatibilità non invia comandi di gioco e non dispone di un getter pubblico documentato da leggere.

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.AddRecall");
UO.AddRecall("0x40012345");

1. Salvare il valore come dati di compatibilità, non eseguire Recall. - sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Salvare il valore come dati di compatibilità, non eseguire Recall.
UO.AddRecall("0x40012345");

2. Passa l'identificatore tramite una variabile stringa. - funzione di script

Parametri e flusso di esecuzione:

  • Passa l'identificatore tramite una variabile stringa.
return  RunScenario();
 object? RunScenario()
{
    var bookSerial = "0x40012345";
    UO.AddRecall(bookSerial);
    return null;
}

3. Ogni chiamata aggiunge una voce separata a AddRecall del runtime corrente. - lezione di sceneggiatura

Parametri e flusso di esecuzione:

  • Ogni chiamata aggiunge una voce separata a AddRecall del runtime corrente.
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.AddRecall("0x40012345");
        UO.AddRecall("0x40012346");
        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.AddRecall(bookSerial) — UO.AddRecall(Any)

Parametri: bookSerial (Any)

Risultato: void / Unit.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "adddir":

                case "addfindlist":

                case "addgate":

                case "addrecall":

                case "addstep":

                    LegacyList(name).Add(string.Join("|", arguments.Select(value => value.ToString())));

                    break;

UO.Cast

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

Firme C#

int UO.Cast(object? spellName);

Richiede l'uso di un incantesimo per nome. Esattamente un parametro: spellName, ad esempio UO.Cast("Heal"). Il bersaglio viene selezionato separatamente: con il mouse utilizzando il mirino visualizzato o tramite WaitTargetObject prima di Cast. Accettare una richiesta non conferma un effetto positivo.

Parametri

  • spellName - Riga richiesta - il nome inglese dell'incantesimo tra virgolette: "Heal", "Cure", "Greater Heal". I nomi non vengono tradotti insieme all'interfaccia. Il dizionario riconosce anche gli alias incorporati e le parole ortografiche. Il numero ID, inclusa la stringa "29", target, distanza, notorietà, maxZ e attesa non sono parametri di Cast. Tutti i nomi e le scuole.

Valore restituito

int: 1/true—il cliente ha accettato la richiesta; 0/false - il nome non viene riconosciuto oppure la richiesta viene rifiutata localmente. Puoi scrivere se UO.Cast("Heal") { ... } o confrontare con 1/true. Questi non sono incantesimi ID o prove di guarigione/danno. Un argomento mancante o aggiuntivo causa un errore. Il comando non prevede la mira e il completamento dell'incantesimo.

Comportamento

  • Forma unica: UO.Cast(spellName). Non ci sono argomenti secondi o successivi. La ricerca di un bersaglio, la preparazione di una risposta, l'attesa e la cancellazione vengono eseguite da comandi separati.
  • Per selezionare manualmente, cancella la coda precedente CancelWaitTarget, chiama Cast e fai clic sull'oggetto desiderato con il mirino. Il Cast stesso non cancella la coda: la sceneggiatura avrebbe potuto prepararla in anticipo.
  • Per un target automatico, chiama prima WaitTargetObject(serial/alias), poi Cast(name). Questo ordine ti consente di rispondere alla mira rapida del server. Per gli incantesimi senza scopo, non preparare una risposta.
  • Il server determina la disponibilità, le risorse, il bersaglio valido, la portata e l'effetto dell'incantesimo. Un esito positivo non fa altro che confermare l'accettazione locale della richiesta.
  • La coda preparata potrebbe rimanere incustodita in caso di guasto del server. Rimuovilo CancelWaitTarget dopo un'attesa limitata o un errore locale. Non eseguire altri script in parallelo con target.
  • Una richiesta accettata viene aggiornata TicksSpell. Cast non aspetta che HP venga animato, guarito o modificato. Il catalogo ID spiega il protocollo interno, ma non sostituisce il nome nell'argomento.

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

1. Cura: seleziona il bersaglio con il mouse - script diretto

Parametri e flusso di esecuzione:

  • La cura è l'unico argomento a favore di Cast. Dopo il lancio, seleziona il personaggio utilizzando il mirino del gioco. Controlla il guasto del server e il risultato del gioco.
UO.CancelWaitTarget();
if (Truth(UO.Cast("Cure")))
{
    UO.Print("Choose the character with the spell cursor");
}
else
{
    UO.Print("Cure request rejected");
}

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

2. Guarigione: obiettivo separato per te stesso - funzione script

Parametri e flusso di esecuzione:

  • self — argomento WaitTargetObject; La guarigione è l'unico argomento di Cast. 3000 - tre secondi per mirare in questo esempio, non è una garanzia di completamento della guarigione. Infine elimina la risposta rimanente e in caso di fallimento.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    UO.CancelWaitTarget();
    try
    {
        UO.WaitTargetObject("self");
        if (Truth(UO.Cast("Heal")))
        {
            await Delay(3000);
        }
    }
    finally
    {
        UO.CancelWaitTarget();
    }

    return null;
}

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

3. Funzionalità completa per l'alleato selezionato: classe dello scenario

Parametri e flusso di esecuzione:

  • spellName, target, cleanupDelayMs - parametri della tua funzione CastAtObject, non sovraccarico UO.Cast. Internamente, Cast accetta solo spellName. ASC converte la stringa ID in un numero; 4000 — ritardo nello svuotamento della coda. true significa accettazione della richiesta, non buon esito del trattamento.

Incantesimi/Incantesimi

Incantesimi/Incantesimi

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 = Asc(UO.GetSerial("lasttarget"), 0);
        if (Truth(await CastAtObject("Greater Heal", target, 4000)))
        {
            UO.Print("Request sent; verify healing in the game");
        }

        return null;
    }

    async Task<dynamic> CastAtObject(dynamic spellName, dynamic target, dynamic cleanupDelayMs)
    {
        if (!(Truth(UO.Connected())) || Truth(UO.Dead()) || Truth(target <= 0) || !(Truth(UO.Exists(target))))
        {
            return false;
        }

        dynamic accepted = false;
        UO.CancelWaitTarget();
        try
        {
            UO.WaitTargetObject(target);
            accepted = UO.Cast(spellName);
            if (Truth(accepted))
            {
                await Delay(cleanupDelayMs);
            }
        }
        finally
        {
            UO.CancelWaitTarget();
        }

        return accepted;
    }

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

    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.Cast(spellName) — UO.Cast(String)

Parametri: spellName (String)

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int Cast(string spellName)

        {

            if (NumberConversions.TryStr2Int((spellName ?? string.Empty).Trim(), out _))

            {

                SystemMessage("UO.Cast: use one spell name, for example UO.Cast(\"Heal\").");

                return 0;

            }

            return CastCore(spellName) ? 1 : 0;

        }

UO.CastAbility

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

Firme C#

int UO.CastAbility(object? abilityId);

Attiva/disattiva l'abilità attualmente selezionata dell'arma attuale tramite UseAbility: richiamare nuovamente un'abilità già selezionata la deseleziona.

Parametri

  • abilityId — Nome dell'abilità o stringa numerica risolta da ResolveClassicUOAbilityId; il valore sconosciuto dà 0.

Valore restituito

int 1 — il client ha chiamato l'attuale abilità primaria/secondaria; 0 - nessun personaggio, sconosciuto ID o l'abilità non corrisponde all'arma attuale.

Comportamento

  • 1 descrive l'accettazione di una richiesta del client, piuttosto che un successo o la cancellazione di risorse da parte del server. ID, che non è l'abilità primaria/secondaria corrente, restituisce 0 anche se è nella directory.
  • GameActions.UsePrimaryAbility/UseSecondaryAbility controlla il bit 0x80. Quando il bit è spento, deseleziona l'altra opzione e invia l'abilità selezionata; quando già abilitato, inviare ID 0 per disabilitare. Quindi il bit viene cambiato. Il ritorno a 1 conferma la chiamata a questo ramo cliente, compreso lo spegnimento.

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

1. Risolvi il nome dell'abilità: script diretto

Parametri e flusso di esecuzione:

  • La disponibilità nel catalogo è separata dall'abbinamento delle armi.
var id = UO.GetAbilityID("Armor Ignore");
if (Truth(id > 0))
{
    var accepted = UO.CastAbility(id);
    UO.Print(Convert.ToString(accepted));
}

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

2. Chiama per nome - funzione script

Parametri e flusso di esecuzione:

  • Il nome si risolve in ID e viene confrontato con l'arma corrente.
return  RunScenario();
 object? RunScenario()
{
    var accepted = UO.CastAbility("Armor Ignore");
    UO.Print(Convert.ToString(accepted));
    return null;
}

3. ID non valido: classe di script

Parametri e flusso di esecuzione:

  • Zero è fuori dalla directory e restituisce 0 senza attivazione.

Incantesimi/Incantesimi

Incantesimi/Incantesimi

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 accepted = UO.CastAbility(0);
        UO.Print(Convert.ToString(accepted));
        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.CastAbility(abilityId) — UO.CastAbility(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.CastAbility(abilityId) — UO.CastAbility(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.CastToObject

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

Firme C#

dynamic UO.CastToObject(object? spellName, object? objID);

Posiziona un oggetto bersaglio in attesa e invia un incantesimo per nome o numerico ID.

Parametri

  • spellName - string con il nome dell'incantesimo, incluso il carattere di sottolineatura al posto dello spazio, o un numero ID per bridge.Cast.
  • objID — Numero seriale dell'oggetto o nome supportato di self/backpack/lasttarget/oggetto salvato; le stringhe numeriche e le stringhe 0x vengono risolte dal runtime.

Valore restituito

risultato int/booleano 1 — il client ha accettato la richiesta Cast; 0: richiesta respinta. Il successo dell'incantesimo non è confermato dal server.

Comportamento

  • La forma della stringa passa attraverso CastAtTarget; la forma numerica mette WaitTargetObject, quindi bridge.Cast. Se Cast fallisce, il target in sospeso viene annullato. Dopo l'accettazione, ticksSpell viene aggiornato.
  • Il bridge rifiuta spellId non positivo, nessuna connessione e carattere morto. Il timer segna l'invio, non la fine del cast; il risultato dell'impatto sull'oggetto dipende 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.

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

1. Regalati te stesso: sceneggiatura diretta

Parametri e flusso di esecuzione:

  • Heal rende self la destinazione del successivo cursore del server.
var accepted = UO.CastToObject("Heal", "self");
UO.Print(Convert.ToString(accepted));

2. Numerico ID - funzione dello script

Parametri e flusso di esecuzione:

  • La forma numerica passa ID 4 al client; 1 significa inviare una richiesta.
return  RunScenario();
 object? RunScenario()
{
    var accepted = UO.CastToObject(4, UO.Self());
    UO.Print(Convert.ToString(accepted));
    return null;
}

3. Controlla Oggetto selezionato - Classe script

Parametri e flusso di esecuzione:

  • Il controllo dell'esistenza locale aiuta a evitare l'utilizzo di un lasttarget mancante.

Incantesimi/Incantesimi

Incantesimi/Incantesimi

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 target = UO.LastTarget();
        if (Truth(UO.Exists(target)))
        {
            var accepted = UO.CastToObject("Greater Heal", target);
            UO.Print(Convert.ToString(accepted));
        }

        return null;
    }

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

Implementazione del comando

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

UO.CastToObject(spellName, objID) — UO.CastToObject(Any,Any)

Parametri: spellName (Any), objID (Any)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "casttoobject":

                    if (arguments[0].Kind == InjectionValueKind.String)

                        return CastAtTarget(arguments[0], arguments[1]) != 0 ? InjectionValue.True : InjectionValue.False;



                    WaitTargetObject(Arg(1));

                    int castAccepted = bridge.Cast(Arg(0));

                    if (castAccepted != 0)

                    {

                        ticksSpell = Timer();

                        return InjectionValue.True;

                    }



                    bridge.CancelTarget();

                    return InjectionValue.False;

UO.IsActiveSpellAbility

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

Firme C#

dynamic UO.IsActiveSpellAbility(object? spellName);

Controlla se il server ha segnalato lo stato attivo dell'abilità/incantesimo selezionato. Utile prima di riattivare un'abilità canalizzata. Non accende nulla, non lancia né seleziona un bersaglio.

Parametri

  • spellName - Unico parametro richiesto: un nome inglese dal catalogo degli incantesimi o l'intero ID. Ad esempio, "Fiducia" e 402 rappresentano lo stesso incantesimo Bushido. Il caso non è importante; i caratteri di sottolineatura nel nome vengono sostituiti con spazi. Viene riconosciuta anche la linea numerica. Non superare il carattere ID, l'oggetto type o il numero di abilità.

Valore restituito

int: 1 - il server ha segnalato lo stato attivo di questo ID; 0 - al momento non esiste uno stato attivo del genere. In C# controlla il risultato numerico: if (UO.IsActiveSpellAbility(402) != 0) { ... }. Questo è un segno logico, non il numero, il tempo o il risultato dell'ultimo lancio. Nome sconosciuto, ID fuori 1…65535 e nessuno stato risultante fornisce anche 0.

Comportamento

  • L'elenco aggiorna il pacchetto server 0xBF/0x25: abilitandolo aggiunge ID, disabilitandolo lo rimuove. Funziona senza finestra grafica e senza pulsante di incantesimo sullo schermo. La chiusura di una finestra salva lo stato; interrompere la connessione lo cancella. Rispondere 0 non prova che il personaggio non sia in grado di lanciare l'incantesimo. Il server dovrebbe inviare questo stato; Questo non è un controllo universale per tutti i buff. Per Guarigione/Richiamo istantaneo, un esempio del genere non conferma un lancio riuscito. La durata dell'incantesimo, il mana rimanente, la disponibilità e il successo non sono determinati da questo comando.

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

1. Controllo dello stato utilizzando ID - script diretto

Parametri e flusso di esecuzione:

  • 402 - ID Fiducia. La variabile attiva contiene 1 o 0; true è equivalente a 1 qui. Il messaggio descrive lo stato ricevuto, non il risultato del tentativo di cast.
var active = UO.IsActiveSpellAbility(402);
if (Truth(Truth(active) == true))
{
    UO.Print("Confidence is active");
}
else
{
    UO.Print("No active Confidence state received");
}

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

2. Non ripetere l'abilità attiva - Funzione script

Parametri e flusso di esecuzione:

  • "Fiducia" - lo stesso ID 402. Cast accetta solo il nome. La richiesta viene inviata una volta se non è presente uno stato attivo; non garantisce il successo sul server. Non eseguire questo frammento in un ciclo veloce; la risposta del server potrebbe subire ritardi.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.IsActiveSpellAbility("Confidence") == 0))
    {
        UO.Cast("Confidence");
    }

    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. In attesa di riconoscimento con limite - Classe script

Parametri e flusso di esecuzione:

  • spell - nome o ID; previsto — true per accendere, false per spegnere; timeoutMs: limite di attesa in millisecondi. Main attende fino a 500 ms con controlli ogni 25 ms e non lancia nulla. La funzione restituisce true se c'è una corrispondenza, altrimenti false. Questa è un'aspettativa limitata di uno stato locale, non una prova del motivo del suo cambiamento; il tempo effettivo può aumentare se lo script è in pausa o sotto carico.

Incantesimi/Incantesimi

Incantesimi/Incantesimi

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

     public object? RunScenario()
    {
        if (Truth(WaitAbilityState("Confidence", true, 500)))
        {
            UO.Print("Active state received");
        }
        else
        {
            UO.Print("No active state before timeout");
        }

        return null;
    }

    dynamic WaitAbilityState(dynamic spell, dynamic expected, dynamic timeoutMs)
    {
        var elapsed = 0;
        while (Truth(elapsed < timeoutMs))
        {
            if (Truth((UO.IsActiveSpellAbility(spell) == 1) == expected))
            {
                return true;
            }

            UO.Wait(25);
            elapsed = elapsed + 25;
        }

        return Truth((UO.IsActiveSpellAbility(spell) == 1) == expected);
    }

    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.IsActiveSpellAbility(spellName) — UO.IsActiveSpellAbility(Any)

Parametri: spellName (Any)

Risultato: dynamic / Any.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

case "isactivespellability":

                {

                    int? spellId = arguments[0].Kind == InjectionValueKind.String

                        ? ConvertSpellName(Text(0).Replace('_', ' '))

                        : (int?)Arg(0);

                    return new InjectionValue(spellId.HasValue ? bridge.IsActiveSpell(spellId.Value) : 0);

                }

UO.TicksSpell

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

Firme C#

int UO.TicksSpell();

Legge il contrassegno salvato TicksSpell.

Parametri

Non ci sono parametri.

Valore restituito

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

Comportamento

  • Restituisce il campo ticksSpell. Viene aggiornato dal Cast/CastAtTarget accettato con successo; non si tratta di un'osservazione automatica di tutte le attività manuali/server. Il comando in sé non modifica il segno.
  • UO.Timer() - il voto calcola l'età in decimi di secondo. I voti non vengono confrontati tra tempi di esecuzione diversi.

Script C# autonomi

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

Esempio semplice

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

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

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

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

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

  • Restituisce il campo ticksSpell. Viene aggiornato dal Cast/CastAtTarget accettato con successo; non si tratta di un'osservazione automatica di tutte le attività manuali/server. Il comando in sé non modifica il segno.
return  RunScenario();
 object? RunScenario()
{
    var stamp = UO.TicksSpell();
    var ageTenths = UO.Timer() - stamp;
    UO.Print(ageTenths);
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

  • UO.Timer() - il voto calcola l'età in decimi di secondo. I voti non vengono confrontati tra tempi di esecuzione diversi.

Incantesimi/Incantesimi

Incantesimi/Incantesimi

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.TicksSpell();
        UO.Wait(250);
        var after = UO.TicksSpell();
        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.TicksSpell() — UO.TicksSpell()

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

Codice interno di implementazione; non è uno script autonomo.

public int TicksSpell() => ticksSpell;

ClassicUO — Bad Newbie & C# Scripts IDE

ClassicUO — Bad Newbie & C# Scripts IDE

Clone this wiki locally