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

Competenze

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

Applicazione delle competenze, lettura dei valori e gestione dei blocchi delle competenze. Il nome della competenza e la disponibilità dell'azione dipendono dai dati supportati dal client/server.

Abilità: nomi e numeri esatti

Apri catalogo completo ed esempi

Sezioni

Argomento	Comandi e spiegazioni
UseSkill	UO.UseSkill
Skill Value	UO.GetSkillValue · UO.SkillVal
Skill Current Value	UO.GetSkillCurrentValue
Skill Cap	UO.GetSkillCap
Skill Locks	UO.GetSkillLockState · UO.SetSkillLockState
Tracking	UO.Track
Snooping	UO.Snoop
Stealth	UO.StealthCnt · UO.UseSkill

Tutti i comandi del tema

Competenze

UO.UseSkill · UO.GetSkillCap · UO.GetSkillCurrentValue · UO.GetSkillValue · UO.GetSkillLockState · UO.SetSkillLockState · UO.SkillLockState · UO.SkillVal · UO.Track · UO.Snoop · UO.StealthCnt · UO.TicksSkill

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

Parametri, risultato e tutti gli scenari

if (!(Truth(UO.Connected())) || Truth(UO.Dead()) || Truth(UO.Hidden()))
{
    return null;
}
if (!(Truth(UO.UseSkill("Hiding"))))
{
    UO.Print("Hiding request rejected");
    return null;
}
await Delay(1000);
if (Truth(UO.Hidden()))
{
    UO.Print("Character is hidden");
}
else
{
    UO.Print("Not hidden yet; check the game journal");
}

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;

UO.GetSkillValue

Parametri, risultato e tutti gli scenari

var selector = "Mining";
var value = UO.GetSkillValue(selector);
UO.Print(Convert.ToString(value));

Riferimento completo dei comandi

UO.GetSkillCap

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

Firme C#

double UO.GetSkillCap(object? skillName);

Legge il limite di abilità ricevuto dal server.

Parametri

skillName - Abilità richiesta: un nome dai dati del cliente, come "Estrazione" o "Sapere animali", o un indice decimale da 0 a Skills.Length−1, numero o stringa. Il caso del nome non è importante, gli spazi finali vengono rimossi, _ viene sostituito con uno spazio. L'indice non è il ID del soggetto o l'indice di 1. Una stringa numerica indica sempre un indice.

Valore restituito

double (Double) - punti abilità in incrementi di 0,1, ad esempio 95,1, non 951. Il campo CapFixed è diviso da 10 direttamente in Double. 0 significa abilità zero o nessun personaggio/abilità. Il risultato non è bool. Legacy SkillVal/BaseVal hanno una scala diversa: non mescolare queste famiglie.

Comportamento

La lettura viene effettuata tramite Invoke sul thread di gioco in base ai dati già ricevuti; i pacchetti di rete non vengono inviati. L'abilità non viene utilizzata né allenata. Due richieste: due snapshot separati.
Abilità richiesta: un nome dai dati del cliente, come "Estrazione" o "Sapere animali", o un indice decimale da 0 a Skills.Length−1, numero o stringa. Il caso del nome non è importante, gli spazi finali vengono rimossi, _ viene sostituito con uno spazio. L'indice non è il ID del soggetto o l'indice di 1. Una stringa numerica indica sempre un indice.
ExecuteClientApiCompatibility seleziona il ramo di comando. Il testo legge il selettore delle abilità, Arg legge i numeri numerici e le modalità. Un argomento non convertibile potrebbe fallire la chiamata con un errore di conversione.

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

1. Lettura e output: script diretto

Parametri e flusso di esecuzione:

Nell'esempio, il selettore e, durante la registrazione, la modalità sono specificati esplicitamente. La prima riga seleziona un'abilità per nome o una caratteristica per numero. Print visualizza solo il risultato.

var selector = "Mining";
var value = UO.GetSkillCap(selector);
UO.Print(Convert.ToString(value));

2. Applica in condizione o confronto - funzione script

Parametri e flusso di esecuzione:

La soglia 95.1 e le modalità 0/1/2 sono fornite come esempio. −1 viene controllato prima di cambiare modalità. Dopo la scrittura viene letta solo la copia locale; non sta aspettando che il server risponda.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.GetSkillLockState("Mining") >= 0))
    {
        var value = UO.GetSkillCap("Mining");
        if (Truth(value >= 95.1))
        {
            UO.Print("Value >= 95.1: " + Convert.ToString(value));
        }
    }

    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:

Tutto il codice helper è riportato di seguito Main. il selettore seleziona un'abilità/caratteristica, la modalità imposta la modalità di registrazione. ReadValue/ReadMode restituisce il numero originale; ApplyMode controlla gli argomenti, esegue l'azione e non restituisce un valore. UO.Wait(1000) nell'esempio di lettura separa due immagini.

Competenze

Abilità

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 before = ReadValue("Animal_Lore");
        await Delay(1000);
        var after = ReadValue("Animal Lore");
        UO.Print(Convert.ToString(after - before));
        return null;
    }

    dynamic ReadValue(dynamic selector)
    {
        return UO.GetSkillCap(selector);
    }

    Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
}

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.GetSkillCap(skillName)` — `UO.GetSkillCap(Any)`

Parametri: skillName (Any)

Risultato: double / Decimal.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetSkillValue: bridge.GetSkillValue(Text(0), false, true).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Text: Text(0).

Codice interno di implementazione; non è uno script autonomo.

case "getskillcap": return new InjectionValue(bridge.GetSkillValue(Text(0), false, true));

UO.GetSkillCurrentValue

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

Firme C#

double UO.GetSkillCurrentValue(object? skillName);

Legge il valore effettivo dell'abilità con i modificatori.

Parametri

skillName - Abilità richiesta: un nome dai dati del cliente, come "Estrazione" o "Sapere animali", o un indice decimale da 0 a Skills.Length−1, numero o stringa. Il caso del nome non è importante, gli spazi finali vengono rimossi, _ viene sostituito con uno spazio. L'indice non è il ID del soggetto o l'indice di 1. Una stringa numerica indica sempre un indice.

Valore restituito

double (Double) - punti abilità in incrementi di 0,1, ad esempio 95,1, non 951. Il campo ValueFixed è diviso da 10 direttamente in Double. 0 significa abilità zero o nessun personaggio/abilità. Il risultato non è bool. Legacy SkillVal/BaseVal hanno una scala diversa: non mescolare queste famiglie.

Comportamento

La lettura viene effettuata tramite Invoke sul thread di gioco in base ai dati già ricevuti; i pacchetti di rete non vengono inviati. L'abilità non viene utilizzata né allenata. Due richieste: due snapshot separati.
Abilità richiesta: un nome dai dati del cliente, come "Estrazione" o "Sapere animali", o un indice decimale da 0 a Skills.Length−1, numero o stringa. Il caso del nome non è importante, gli spazi finali vengono rimossi, _ viene sostituito con uno spazio. L'indice non è il ID del soggetto o l'indice di 1. Una stringa numerica indica sempre un indice.
ExecuteClientApiCompatibility seleziona il ramo di comando. Il testo legge il selettore delle abilità, Arg legge i numeri numerici e le modalità. Un argomento non convertibile potrebbe fallire la chiamata con un errore di conversione.

Script C# autonomi

Esempio semplice

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

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

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

1. Lettura e output: script diretto

Parametri e flusso di esecuzione:

Nell'esempio, il selettore e, durante la registrazione, la modalità sono specificati esplicitamente. La prima riga seleziona un'abilità per nome o una caratteristica per numero. Print visualizza solo il risultato.

var selector = "Mining";
var value = UO.GetSkillCurrentValue(selector);
UO.Print(Convert.ToString(value));

2. Applica in condizione o confronto - funzione script

Parametri e flusso di esecuzione:

La soglia 95.1 e le modalità 0/1/2 sono fornite come esempio. −1 viene controllato prima di cambiare modalità. Dopo la scrittura viene letta solo la copia locale; non sta aspettando che il server risponda.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.GetSkillLockState("Mining") >= 0))
    {
        var value = UO.GetSkillCurrentValue("Mining");
        if (Truth(value >= 95.1))
        {
            UO.Print("Value >= 95.1: " + Convert.ToString(value));
        }
    }

    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:

Tutto il codice helper è riportato di seguito Main. il selettore seleziona un'abilità/caratteristica, la modalità imposta la modalità di registrazione. ReadValue/ReadMode restituisce il numero originale; ApplyMode controlla gli argomenti, esegue l'azione e non restituisce un valore. UO.Wait(1000) nell'esempio di lettura separa due immagini.

Competenze

Abilità

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 before = ReadValue("Animal_Lore");
        await Delay(1000);
        var after = ReadValue("Animal Lore");
        UO.Print(Convert.ToString(after - before));
        return null;
    }

    dynamic ReadValue(dynamic selector)
    {
        return UO.GetSkillCurrentValue(selector);
    }

    Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
}

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.GetSkillCurrentValue(skillName)` — `UO.GetSkillCurrentValue(Any)`

Parametri: skillName (Any)

Risultato: double / Decimal.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetSkillValue: bridge.GetSkillValue(Text(0), true, false).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Text: Text(0).

Codice interno di implementazione; non è uno script autonomo.

case "getskillcurrentvalue": return new InjectionValue(bridge.GetSkillValue(Text(0), true, false));

UO.GetSkillLockState

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

Firme C#

int UO.GetSkillLockState(object? skillName);

Legge la modalità di cambio abilità locale.

Parametri

skillName - Abilità richiesta: un nome dai dati del cliente, come "Estrazione" o "Sapere animali", o un indice decimale da 0 a Skills.Length−1, numero o stringa. Il caso del nome non è importante, gli spazi finali vengono rimossi, _ viene sostituito con uno spazio. L'indice non è il ID del soggetto o l'indice di 1. Una stringa numerica indica sempre un indice.

Valore restituito

int: 0 - aumento, 1 - diminuzione, 2 - blocco. Questo è un codice di modalità, non true/false. Per un'abilità sconosciuta o un personaggio mancante, viene restituito −1.

Comportamento

La lettura viene effettuata tramite Invoke sul thread di gioco in base ai dati già ricevuti; i pacchetti di rete non vengono inviati. L'abilità non viene utilizzata né allenata. Due richieste: due snapshot separati.
Abilità richiesta: un nome dai dati del cliente, come "Estrazione" o "Sapere animali", o un indice decimale da 0 a Skills.Length−1, numero o stringa. Il caso del nome non è importante, gli spazi finali vengono rimossi, _ viene sostituito con uno spazio. L'indice non è il ID del soggetto o l'indice di 1. Una stringa numerica indica sempre un indice.
ExecuteClientApiCompatibility seleziona il ramo di comando. Il testo legge il selettore delle abilità, Arg legge i numeri numerici e le modalità. Un argomento non convertibile potrebbe fallire la chiamata con un errore di conversione.

Script C# autonomi

Esempio semplice

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

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

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

1. Lettura e output: script diretto

Parametri e flusso di esecuzione:

Nell'esempio, il selettore e, durante la registrazione, la modalità sono specificati esplicitamente. La prima riga seleziona un'abilità per nome o una caratteristica per numero. Print visualizza solo il risultato.

var selector = "Mining";
var mode = UO.GetSkillLockState(selector);
UO.Print(Convert.ToString(mode));

2. Applica in condizione o confronto - funzione script

Parametri e flusso di esecuzione:

La soglia 95.1 e le modalità 0/1/2 sono fornite come esempio. −1 viene controllato prima di cambiare modalità. Dopo la scrittura viene letta solo la copia locale; non sta aspettando che il server risponda.

return  RunScenario();
 object? RunScenario()
{
    var mode = UO.GetSkillLockState("Mining");
    if (Truth(mode == 2))
    {
        UO.Print("Locked");
    }
    else
    {
        if (Truth(mode == -1))
        {
            UO.Print("Unknown selector");
        }
        else
        {
            UO.Print("Mode: " + Convert.ToString(mode));
        }
    }

    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:

Tutto il codice helper è riportato di seguito Main. il selettore seleziona un'abilità/caratteristica, la modalità imposta la modalità di registrazione. ReadValue/ReadMode restituisce il numero originale; ApplyMode controlla gli argomenti, esegue l'azione e non restituisce un valore. UO.Wait(1000) nell'esempio di lettura separa due immagini.

Competenze

Abilità

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 before = ReadMode("Mining");
        await Delay(1000);
        var after = ReadMode("Mining");
        UO.Print(Convert.ToString(before) + " -> " + Convert.ToString(after));
        return null;
    }

    dynamic ReadMode(dynamic selector)
    {
        return UO.GetSkillLockState(selector);
    }

    Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
}

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.GetSkillLockState(skillName)` — `UO.GetSkillLockState(Any)`

Parametri: skillName (Any)

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetSkillLockState: bridge.GetSkillLockState(Text(0)).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Text: Text(0).

Codice interno di implementazione; non è uno script autonomo.

case "getskilllockstate": return new InjectionValue(bridge.GetSkillLockState(Text(0)));

UO.GetSkillValue

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

Firme C#

double UO.GetSkillValue(object? skillName);

Legge il valore base dell'abilità senza modificatori.

Parametri

skillName - Abilità richiesta: un nome dai dati del cliente, come "Estrazione" o "Sapere animali", o un indice decimale da 0 a Skills.Length−1, numero o stringa. Il caso del nome non è importante, gli spazi finali vengono rimossi, _ viene sostituito con uno spazio. L'indice non è il ID del soggetto o l'indice di 1. Una stringa numerica indica sempre un indice.

Valore restituito

double (Double) - punti abilità in incrementi di 0,1, ad esempio 95,1, non 951. Il campo BaseFixed è diviso da 10 direttamente in Double. 0 significa abilità zero o nessun personaggio/abilità. Il risultato non è bool. Legacy SkillVal/BaseVal hanno una scala diversa: non mescolare queste famiglie.

Comportamento

La lettura viene effettuata tramite Invoke sul thread di gioco in base ai dati già ricevuti; i pacchetti di rete non vengono inviati. L'abilità non viene utilizzata né allenata. Due richieste: due snapshot separati.
Abilità richiesta: un nome dai dati del cliente, come "Estrazione" o "Sapere animali", o un indice decimale da 0 a Skills.Length−1, numero o stringa. Il caso del nome non è importante, gli spazi finali vengono rimossi, _ viene sostituito con uno spazio. L'indice non è il ID del soggetto o l'indice di 1. Una stringa numerica indica sempre un indice.
ExecuteClientApiCompatibility seleziona il ramo di comando. Il testo legge il selettore delle abilità, Arg legge i numeri numerici e le modalità. Un argomento non convertibile potrebbe fallire la chiamata con un errore di conversione.

Script C# autonomi

Esempio semplice

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

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

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

1. Lettura e output: script diretto

Parametri e flusso di esecuzione:

Nell'esempio, il selettore e, durante la registrazione, la modalità sono specificati esplicitamente. La prima riga seleziona un'abilità per nome o una caratteristica per numero. Print visualizza solo il risultato.

var selector = "Mining";
var value = UO.GetSkillValue(selector);
UO.Print(Convert.ToString(value));

2. Applica in condizione o confronto - funzione script

Parametri e flusso di esecuzione:

La soglia 95.1 e le modalità 0/1/2 sono fornite come esempio. −1 viene controllato prima di cambiare modalità. Dopo la scrittura viene letta solo la copia locale; non sta aspettando che il server risponda.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.GetSkillLockState("Mining") >= 0))
    {
        var value = UO.GetSkillValue("Mining");
        if (Truth(value >= 95.1))
        {
            UO.Print("Value >= 95.1: " + Convert.ToString(value));
        }
    }

    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:

Tutto il codice helper è riportato di seguito Main. il selettore seleziona un'abilità/caratteristica, la modalità imposta la modalità di registrazione. ReadValue/ReadMode restituisce il numero originale; ApplyMode controlla gli argomenti, esegue l'azione e non restituisce un valore. UO.Wait(1000) nell'esempio di lettura separa due immagini.

Competenze

Abilità

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 before = ReadValue("Animal_Lore");
        await Delay(1000);
        var after = ReadValue("Animal Lore");
        UO.Print(Convert.ToString(after - before));
        return null;
    }

    dynamic ReadValue(dynamic selector)
    {
        return UO.GetSkillValue(selector);
    }

    Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
}

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.GetSkillValue(skillName)` — `UO.GetSkillValue(Any)`

Parametri: skillName (Any)

Risultato: double / Decimal.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetSkillValue: bridge.GetSkillValue(Text(0), false, false).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Text: Text(0).

Codice interno di implementazione; non è uno script autonomo.

case "getskillvalue": return new InjectionValue(bridge.GetSkillValue(Text(0), false, false));

UO.SetSkillLockState

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

Firme C#

void UO.SetSkillLockState(object? skillName, object? skillState);

Richiede una modifica alla modalità abilità.

Parametri

skillName - Abilità richiesta: un nome dai dati del cliente, come "Estrazione" o "Sapere animali", o un indice decimale da 0 a Skills.Length−1, numero o stringa. Il caso del nome non è importante, gli spazi finali vengono rimossi, _ viene sostituito con uno spazio. L'indice non è il ID del soggetto o l'indice di 1. Una stringa numerica indica sempre un indice.
skillState — Modalità obbligatoria: 0 — aumento, 1 — diminuzione, 2 — blocco. Questi sono tre codici, non bool; true/false non sostituiscono i nomi di tutte le modalità.

Valore restituito

void - nessun valore restituito. Il risultato non può essere utilizzato come successo/fallimento o paragonato a true. La lettura successiva mostra il modello locale, non la conferma del server.

Comportamento

Una richiesta valida invia un pacchetto attraverso GameActions e cambia immediatamente la modalità locale. Il server può applicare le proprie restrizioni; Gli aumenti di abilità o statistiche non sono garantiti. Abilità sconosciuta, indice/modalità non validi e carattere mancante vengono ignorati senza pacchetto.
Abilità richiesta: un nome dai dati del cliente, come "Estrazione" o "Sapere animali", o un indice decimale da 0 a Skills.Length−1, numero o stringa. Il caso del nome non è importante, gli spazi finali vengono rimossi, _ viene sostituito con uno spazio. L'indice non è il ID del soggetto o l'indice di 1. Una stringa numerica indica sempre un indice.
ExecuteClientApiCompatibility seleziona il ramo di comando. Il testo legge il selettore delle abilità, Arg legge i numeri numerici e le modalità. Un argomento non convertibile potrebbe fallire la chiamata con un errore di conversione.

Script C# autonomi

Esempio semplice

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

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

UO.Print("Calling UO.SetSkillLockState");
UO.SetSkillLockState("Mining", 2);

1. Lettura e output: script diretto

Parametri e flusso di esecuzione:

Nell'esempio, il selettore e, durante la registrazione, la modalità sono specificati esplicitamente. La prima riga seleziona un'abilità per nome o una caratteristica per numero. Print visualizza solo il risultato.

var selector = "Mining";
var mode = 2;
UO.SetSkillLockState(selector, mode);
UO.Print(Convert.ToString(UO.GetSkillLockState(selector)));

2. Applica in condizione o confronto - funzione script

Parametri e flusso di esecuzione:

La soglia 95.1 e le modalità 0/1/2 sono fornite come esempio. −1 viene controllato prima di cambiare modalità. Dopo la scrittura viene letta solo la copia locale; non sta aspettando che il server risponda.

return  RunScenario();
 object? RunScenario()
{
    var selector = "Mining";
    var before = UO.GetSkillLockState(selector);
    if (Truth(before >= 0) && Truth(before <= 2))
    {
        UO.SetSkillLockState(selector, 0);
        UO.Print(Convert.ToString(UO.GetSkillLockState(selector)));
    }

    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:

Tutto il codice helper è riportato di seguito Main. il selettore seleziona un'abilità/caratteristica, la modalità imposta la modalità di registrazione. ReadValue/ReadMode restituisce il numero originale; ApplyMode controlla gli argomenti, esegue l'azione e non restituisce un valore. UO.Wait(1000) nell'esempio di lettura separa due immagini.

Competenze

Abilità

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("Mining", 2);
        return null;
    }

    void ApplyMode(dynamic selector, dynamic mode)
    {
        if (Truth(mode < 0) || Truth(mode > 2))
        {
            return;
        }

        if (Truth(UO.GetSkillLockState(selector) < 0))
        {
            return;
        }

        UO.SetSkillLockState(selector, mode);
    }

    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.SetSkillLockState(skillName, skillState)` — `UO.SetSkillLockState(Any,Any)`

Parametri: skillName (Any), skillState (Any)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.SetSkillLockState: bridge.SetSkillLockState(Text(0), Arg(1)).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Text: Text(0).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(1).

Codice interno di implementazione; non è uno script autonomo.

case "setskilllockstate":

                case "skilllockstate": bridge.SetSkillLockState(Text(0), Arg(1)); return InjectionValue.Unit;

UO.SkillLockState

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

Firme C#

void UO.SkillLockState(object? skillName, object? skillState);

Richiede una modifica alla modalità abilità.

Parametri

skillName - Abilità richiesta: un nome dai dati del cliente, come "Estrazione" o "Sapere animali", o un indice decimale da 0 a Skills.Length−1, numero o stringa. Il caso del nome non è importante, gli spazi finali vengono rimossi, _ viene sostituito con uno spazio. L'indice non è il ID del soggetto o l'indice di 1. Una stringa numerica indica sempre un indice.
skillState — Modalità obbligatoria: 0 — aumento, 1 — diminuzione, 2 — blocco. Questi sono tre codici, non bool; true/false non sostituiscono i nomi di tutte le modalità.

Valore restituito

void - nessun valore restituito. Il risultato non può essere utilizzato come successo/fallimento o paragonato a true. La lettura successiva mostra il modello locale, non la conferma del server.

Comportamento

Una richiesta valida invia un pacchetto attraverso GameActions e cambia immediatamente la modalità locale. Il server può applicare le proprie restrizioni; Gli aumenti di abilità o statistiche non sono garantiti. Abilità sconosciuta, indice/modalità non validi e carattere mancante vengono ignorati senza pacchetto.
Abilità richiesta: un nome dai dati del cliente, come "Estrazione" o "Sapere animali", o un indice decimale da 0 a Skills.Length−1, numero o stringa. Il caso del nome non è importante, gli spazi finali vengono rimossi, _ viene sostituito con uno spazio. L'indice non è il ID del soggetto o l'indice di 1. Una stringa numerica indica sempre un indice.
ExecuteClientApiCompatibility seleziona il ramo di comando. Il testo legge il selettore delle abilità, Arg legge i numeri numerici e le modalità. Un argomento non convertibile potrebbe fallire la chiamata con un errore di conversione.

Script C# autonomi

Esempio semplice

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

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

UO.Print("Calling UO.SkillLockState");
UO.SkillLockState("Mining", 2);

1. Lettura e output: script diretto

Parametri e flusso di esecuzione:

Nell'esempio, il selettore e, durante la registrazione, la modalità sono specificati esplicitamente. La prima riga seleziona un'abilità per nome o una caratteristica per numero. Print visualizza solo il risultato.

var selector = "Mining";
var mode = 2;
UO.SkillLockState(selector, mode);
UO.Print(Convert.ToString(UO.GetSkillLockState(selector)));

2. Applica in condizione o confronto - funzione script

Parametri e flusso di esecuzione:

La soglia 95.1 e le modalità 0/1/2 sono fornite come esempio. −1 viene controllato prima di cambiare modalità. Dopo la scrittura viene letta solo la copia locale; non sta aspettando che il server risponda.

return  RunScenario();
 object? RunScenario()
{
    var selector = "Mining";
    var before = UO.GetSkillLockState(selector);
    if (Truth(before >= 0) && Truth(before <= 2))
    {
        UO.SkillLockState(selector, 0);
        UO.Print(Convert.ToString(UO.GetSkillLockState(selector)));
    }

    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:

Tutto il codice helper è riportato di seguito Main. il selettore seleziona un'abilità/caratteristica, la modalità imposta la modalità di registrazione. ReadValue/ReadMode restituisce il numero originale; ApplyMode controlla gli argomenti, esegue l'azione e non restituisce un valore. UO.Wait(1000) nell'esempio di lettura separa due immagini.

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("Mining", 2);
        return null;
    }

    void ApplyMode(dynamic selector, dynamic mode)
    {
        if (Truth(mode < 0) || Truth(mode > 2))
        {
            return;
        }

        if (Truth(UO.GetSkillLockState(selector) < 0))
        {
            return;
        }

        UO.SkillLockState(selector, mode);
    }

    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.SkillLockState(skillName, skillState)` — `UO.SkillLockState(Any,Any)`

Parametri: skillName (Any), skillState (Any)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.SetSkillLockState: bridge.SetSkillLockState(Text(0), Arg(1)).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Text: Text(0).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(1).

Codice interno di implementazione; non è uno script autonomo.

case "setskilllockstate":

                case "skilllockstate": bridge.SetSkillLockState(Text(0), Arg(1)); return InjectionValue.Unit;

UO.SkillVal

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

Firme C#

int UO.SkillVal(object? skillName);
int UO.SkillVal(object? skill, object? variant);

Legge il valore ereditato di un'abilità o la sua modalità/crescita.

Parametri

variant - Opzionale int: 0 - valore effettivo (predefinito), 1 - valore base, 2 - aumento del valore base dalla prima lettura di questa abilità in runtime, 3 - modalità di blocco.
skillName — Nome dal dizionario runtime skillNameToSkillId, ad esempio "Mining". Le maiuscole e minuscole non sono importanti, ma gli spazi non vengono tagliati e _ non viene sostituito. Il testo numerico in questa funzione legacy non è un indice; nome sconosciuto visualizza un messaggio e fornisce 0.
skill — Nome dal dizionario runtime skillNameToSkillId, ad esempio "Mining". Le maiuscole e minuscole non sono importanti, ma gli spazi non vengono tagliati e _ non viene sostituito. Il testo numerico in questa funzione legacy non è un indice; nome sconosciuto visualizza un messaggio e fornisce 0.

Valore restituito

int: opzioni 0/1/2 - decimi di punti abilità (951 = 95.1); opzione 3 - modalità 0/1/2 o -1 se non è presente alcun giocatore/abilità. Nome/variante sconosciuto produce 0. L'opzione 2 può essere negativa se la base è inferiore al tempo di esecuzione della linea di base salvato, anche in assenza di Player e base=0. Questo non è bool.

Comportamento

Prima di scegliere la variante, viene preso SkillBaseVal e, se l'abilità viene letta per la prima volta, viene salvata la linea di base. Pertanto, anche la lettura della variante=0/1/3 imposta il punto di partenza per la futura variante di crescita=2.
Una variante errata visualizza un messaggio e restituisce 0, ma la linea di base potrebbe essere già stata creata. I valori GetSkillValue/GetSkillCurrentValue sono misurati con occhiali double e hanno una scala diversa.

Script C# autonomi

Esempio semplice

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

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

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

Legge il valore ereditato di un'abilità o la sua modalità/crescita.

UO.Print(UO.SkillVal("Mining"));
UO.Print(UO.SkillVal("Mining", 1));

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

Prima di scegliere la variante, viene preso SkillBaseVal e, se l'abilità viene letta per la prima volta, viene salvata la linea di base. Pertanto, anche la lettura della variante=0/1/3 imposta il punto di partenza per la futura variante di crescita=2.

return  RunScenario();
 object? RunScenario()
{
    var baseline = UO.SkillVal("Mining", 2);
    UO.Wait(1000);
    UO.Print(UO.SkillVal("Mining", 2) - baseline);
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

Una variante errata visualizza un messaggio e restituisce 0, ma la linea di base potrebbe essere già stata creata. I valori GetSkillValue/GetSkillCurrentValue sono misurati con occhiali double e hanno una scala diversa.

Competenze

Abilità

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 lockMode = UO.SkillVal("Mining", 3);
        if (Truth(lockMode == 2))
        {
            UO.Print("Skill locked");
        }

        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.SkillVal(skillName)` — `UO.SkillVal(String)`

Parametri: skillName (String)

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.SkillVal.
InjectionScript.Runtime.InjectionApiUO.SkillVal: SkillVal(skillName, 0).

Codice interno di implementazione; non è uno script autonomo.

public int SkillVal(string skillName) => SkillVal(skillName, 0);

`UO.SkillVal(skill, variant)` — `UO.SkillVal(Any,Any)`

Parametri: skill (Any), variant (Any)

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Register [SkillVal].
InjectionScript.Runtime.InjectionApiUO.SkillVal: SkillVal(values[0].ToString(), NumberConversions.ToInt(values[1])).
InjectionScript.Runtime.InjectionValue.ToString: values[0].ToString().
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(values[1]).

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(SkillVal(values[0].ToString(), NumberConversions.ToInt(values[1])))

UO.Snoop

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

Firme C#

void UO.Snoop();
void UO.Snoop(object? container);

Utilizza un contenitore/oggetto, in genere richiedendone l'apertura.

Parametri

container - Opzionale serial/alias. L'impostazione predefinita è bridge.LastTarget. Il comando non controlla IsContainer o l'affiliazione.

Valore restituito

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

Comportamento

ExecuteLegacyManualAlias chiama bridge.UseObject(Arg(0,bridge.LastTarget)). Questa è una normale richiesta di clic double, non un algoritmo client separato per l'abilità Snooping.
Bridge invia la richiesta sullo streaming del gioco. Si applicano le regole del server; Non è prevista l'attesa di conferma.

Script C# autonomi

Esempio semplice

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

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

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

Utilizza un contenitore/oggetto, in genere richiedendone l'apertura.

UO.Snoop();

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

ExecuteLegacyManualAlias chiama bridge.UseObject(Arg(0,bridge.LastTarget)). Questa è una normale richiesta di clic double, non un algoritmo client separato per l'abilità Snooping.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.IsContainer("lasttarget")))
    {
        UO.Snoop("lasttarget");
    }

    return null;
}

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

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

Bridge invia la richiesta sullo streaming del gioco. Si applicano le regole del server; Non è prevista l'attesa di conferma.

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

     public object? RunScenario()
    {
        var id = UO.GetSerial("lasttarget");
        if (Truth(UO.Exists(id)))
        {
            UO.Snoop(id);
            UO.Wait(500);
            UO.Print(UO.GetContent(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.Snoop()` — `UO.Snoop()`

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.UseObject: bridge.UseObject(Arg(0, bridge.LastTarget)).
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Arg: Arg(0, bridge.LastTarget).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.LastTarget: bridge.LastTarget.

Codice interno di implementazione; non è uno script autonomo.

case "snoop": bridge.UseObject(Arg(0, bridge.LastTarget)); break;

`UO.Snoop(container)` — `UO.Snoop(Any)`

Parametri: container (Any)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.UseObject: bridge.UseObject(Arg(0, bridge.LastTarget)).
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Arg: Arg(0, bridge.LastTarget).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.LastTarget: bridge.LastTarget.

Codice interno di implementazione; non è uno script autonomo.

case "snoop": bridge.UseObject(Arg(0, bridge.LastTarget)); break;

UO.StealthCnt

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

Firme C#

int UO.StealthCnt();

Legge il contatore dello spostamento furtivo locale del personaggio.

Parametri

Non ci sono parametri.

Valore restituito

int è la somma accumulata max(abs(deltaX),abs(deltaY)) tra le chiamate a IsHidden. Questo non è un numero garantito di passaggi invisibili del server o il limite rimanente.

Comportamento

Senza Giocatore o quando il Giocatore non è nascosto, reimposta il conteggio=0 e salva l'X/Y corrente (o -1). In modalità invisibile, confronta con X/Y salvati in precedenza, aggiunge offset e aggiorna le coordinate.
Il contatore cambia man mano che viene letto. È possibile saltare lo spostamento avanti e indietro tra le chiamate; la modifica di Z senza X/Y non aumenta il contatore.

Script C# autonomi

Esempio semplice

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

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

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

Legge il contatore dello spostamento furtivo locale del personaggio.

UO.Print(UO.StealthCnt());

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

Senza Giocatore o quando il Giocatore non è nascosto, reimposta il conteggio=0 e salva l'X/Y corrente (o -1). In modalità invisibile, confronta con X/Y salvati in precedenza, aggiunge offset e aggiorna le coordinate.

return  RunScenario();
 object? RunScenario()
{
    var before = UO.StealthCnt();
    UO.Wait(500);
    UO.Print(UO.StealthCnt() - before);
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

Il contatore cambia man mano che viene letto. È possibile saltare lo spostamento avanti e indietro tra le chiamate; la modifica di Z senza X/Y non aumenta il contatore.

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

     public object? RunScenario()
    {
        if (Truth(UO.Hidden()))
        {
            UO.Print(UO.StealthCnt());
        }
        else
        {
            UO.Print(UO.StealthCnt());
        }

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

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

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

UO.TicksSkill

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

Firme C#

int UO.TicksSkill();

Legge il contrassegno salvato TicksSkill.

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 ticksSkill. Viene aggiornato dal UseSkill/UseSkillAtTarget 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

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

Legge il contrassegno salvato TicksSkill.

var stamp = UO.TicksSkill();
UO.Print(stamp);

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

Restituisce il campo ticksSkill. Viene aggiornato dal UseSkill/UseSkillAtTarget 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.TicksSkill();
    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.

Competenze

Abilità

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

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.TicksSkill.

Codice interno di implementazione; non è uno script autonomo.

public int TicksSkill() => ticksSkill;

UO.Track

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

Firme C#

void UO.Track();
void UO.Track(object? flag);
void UO.Track(object? flagRaw, object? x, object? y);

Crea o rimuove una freccia locale alle coordinate. Aiuta a segnare il luogo del ritorno. Non attiva l'abilità Tracciamento, non cerca creature e non muove il personaggio.

Parametri

flag — 0 — rimuove la freccia locale; qualsiasi altro intero - spettacolo. UO.Track() e UO.Track(1) posizionalo nell'attuale X/Y del personaggio. UO.Track(1, x, y) lo posiziona nel punto indicato; UO.Track(0, x, y) ignora le coordinate. Il modulo a due parametri non è incluso nel API registrato.
flagRaw — 0 — rimuove la freccia locale; qualsiasi altro intero - spettacolo. UO.Track() e UO.Track(1) posizionalo nell'attuale X/Y del personaggio. UO.Track(1, x, y) lo posiziona nel punto indicato; UO.Track(0, x, y) ignora le coordinate. Il modulo a due parametri non è incluso nel API registrato.
x - Coordinate della cella sulla mappa corrente, non pixel della finestra. Z e numero della carta non sono accettati. Seleziona un punto esistente sulla tua mappa; la squadra non controlla il terreno, traccia un percorso o segue un bersaglio in movimento.
y - Coordinate della cella sulla mappa corrente, non pixel della finestra. Z e numero della carta non sono accettati. Seleziona un punto esistente sulla tua mappa; la squadra non controlla il terreno, traccia un percorso o segue un bersaglio in movimento.

Valore restituito

void - nessun valore; il comando non restituisce il successo della mossa o bool. Viene modificato solo il token locale.

Comportamento

Il server e le frecce locali vengono archiviate separatamente. Track(0) non rimuove la freccia del server. Senza grafica, il marcatore viene salvato e appare all'apertura della finestra. La chiusura della finestra di gioco non rimuove i segnalini; interrompere la connessione li cancella. Il server può spostare o rimuovere la sua freccia. Le coordinate non dimostrano che l’obiettivo è raggiungibile.
Coordinate della cella sulla mappa corrente, non pixel della finestra. Z e numero della carta non sono accettati. Seleziona un punto esistente sulla tua mappa; la squadra non controlla il terreno, traccia un percorso o segue un bersaglio in movimento.
0 — rimuove la freccia locale; qualsiasi altro intero - spettacolo. UO.Track() e UO.Track(1) posizionalo nell'attuale X/Y del personaggio. UO.Track(1, x, y) lo posiziona nel punto indicato; UO.Track(0, x, y) ignora le coordinate. Il modulo a due parametri non è incluso nel API registrato.

Script C# autonomi

Esempio semplice

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

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

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

1. Applicazione diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

UO.Track() ricorda il punto attuale: dopo essere usciti, la freccia punta indietro. Il punto non viene aggiornato automaticamente dopo il carattere.

UO.Track();

2. Condizioni del gioco - funzione scenario

Parametri e flusso di esecuzione:

Mostra una freccia locale verso 1450,1690 sulla mappa corrente. Se sei già all'interno di un quadrato, Track(0) lo rimuove. Sostituisci le tue coordinate.

return  RunScenario();
 object? RunScenario()
{
    var x = 1450;
    var y = 1690;
    UO.Track(1, x, y);
    if (Truth(UO.GetDistance(x, y) <= 1))
    {
        UO.Track(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:

La funzione MarkIfDistant utilizza gli stessi X/Y e la stessa distanza: se il bersaglio è più lontano di due celle, inserisce una freccia, altrimenti la rimuove. L'intera funzione è mostrata di seguito; non c'è movimento o aspettativa di realizzazione qui.

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()
    {
        MarkIfDistant(1450, 1690);
        return null;
    }

    void MarkIfDistant(dynamic x, dynamic y)
    {
        if (Truth(UO.GetDistance(x, y) > 2))
        {
            UO.Track(1, x, y);
        }
        else
        {
            UO.Track(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.Track()` — `UO.Track()`

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Track.
InjectionScript.Runtime.InjectionApiUO.Track: Track(1, GetX(), GetY()).
InjectionScript.Runtime.InjectionApiUO.GetX: GetX().
InjectionScript.Runtime.InjectionApiUO.GetY: GetY().

Codice interno di implementazione; non è uno script autonomo.

public void Track() => Track(1, GetX(), GetY());

`UO.Track(flag)` — `UO.Track(Any)`

Parametri: flag (Any)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Track.
InjectionScript.Runtime.InjectionApiUO.Track: Track(NumberConversions.ToInt(flag), GetX(), GetY()).
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(flag).
InjectionScript.Runtime.InjectionApiUO.GetX: GetX().
InjectionScript.Runtime.InjectionApiUO.GetY: GetY().

Codice interno di implementazione; non è uno script autonomo.

public void Track(InjectionValue flag) => Track(NumberConversions.ToInt(flag), GetX(), GetY());

`UO.Track(flagRaw, x, y)` — `UO.Track(Any,Any,Any)`

Parametri: flagRaw (Any), x (Any), y (Any)

Risultato: void / Unit.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.Track.
InjectionScript.Runtime.InjectionApiUO.Track: Track(NumberConversions.ToInt(flagRaw), NumberConversions.ToInt(x), NumberConversions.ToInt(y)).
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(flagRaw).

Codice interno di implementazione; non è uno script autonomo.

public void Track(InjectionValue flagRaw, InjectionValue x, InjectionValue y)

            => Track(NumberConversions.ToInt(flagRaw), NumberConversions.ToInt(x), NumberConversions.ToInt(y));

UO.UseSkill

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

Firme C#

int UO.UseSkill(object? skillName);

Chiede al server di utilizzare l'abilità per nome. Esattamente un parametro: skillName. UO.UseSkill("Hiding") cerca di nascondere il proprio carattere. Se l'abilità necessita di un bersaglio, selezionalo con il mirino del gioco o in anticipo con un comando separato WaitTargetObject.

Parametri

skillName - Stringa richiesta: il nome inglese esatto dell'abilità, come "Nascondersi", "Anatomia" o "Meditazione". Il caso non è importante; gli spazi e i caratteri di sottolineatura non vengono corretti automaticamente. Il numero dell'abilità, serial, self, la distanza, la notorietà, maxZ e l'attesa non vengono trasferiti qui. Tutti i nomi.

Valore restituito

int: 1/true—il cliente ha accettato la richiesta; 0/false - nome sconosciuto o errore locale. Questo non è un successo di abilità, una crescita di abilità o un segno di azione furtiva. Per la lettura furtiva Hidden(). Puoi scrivere se UO.UseSkill("Hiding") { ... } o confrontare con 1/true. Un argomento mancante o aggiuntivo è un errore di chiamata.

Comportamento

Forma unica: UO.UseSkill(skillName). Non ci sono parametri secondi o successivi. La ricerca, il target e l'attesa vengono eseguiti da altri comandi.
Nascondersi e Meditare non richiedono la selezione di un altro oggetto. Non preparare WaitTargetObject per loro: la raffica rimanente potrebbe rispondere alla vista del prossimo outsider.
L'anatomia utilizza un mirino. Chiama UseSkill("Anatomia") e seleziona il personaggio con il mouse. Per rispondere automaticamente, esegui prima WaitTargetObject, poi UseSkill: in questo modo non perderai la risposta rapida del server.
UseSkill non crea né cancella la coda di destinazione. Se hai preparato una risposta, cancellala CancelWaitTarget in caso di errore/timeout. Non eseguire altri scenari di avvistamento contemporaneamente.
Avvelenamento, Provocazione e altre abilità a più fasi richiedono l'elaborazione separata di obiettivi/strumenti aggiuntivi. Un oggetto preselezionato non completa alcuna abilità.
Il nome nel dizionario non garantisce l'uso senza strumento. L'estrazione mineraria richiede uno strumento; gli incantesimi vengono lanciati da Cast. Le regole e il successo sono determinati dal server.
Una richiesta accettata viene aggiornata TicksSkill. La squadra non si aspetta furtività, effetti, aumento delle abilità o consumo della coda.

Script C# autonomi

Esempio semplice

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

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

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

1. Nascondi tramite Nascondi - script diretto

Parametri e flusso di esecuzione:

Nascondersi è l'unico argomento. UO.Wait(1000) dà tempo per rispondere; Hidden legge il flag ricevuto. Ritornare da 1 da UseSkill non significa che sei scappato.

if (!(Truth(UO.Connected())) || Truth(UO.Dead()) || Truth(UO.Hidden()))
{
    return null;
}
if (!(Truth(UO.UseSkill("Hiding"))))
{
    UO.Print("Hiding request rejected");
    return null;
}
await Delay(1000);
if (Truth(UO.Hidden()))
{
    UO.Print("Character is hidden");
}
else
{
    UO.Print("Not hidden yet; check the game journal");
}

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;

2. Anatomia con un target preparato separatamente - funzione script

Parametri e flusso di esecuzione:

L'anatomia è l'unico parametro UseSkill; mobile si riferisce a WaitTargetObject. ASC converte la stringa esadecimale GetSerial in un numero per il controllo dell'intervallo. 1500 — millisecondi di attesa nell'esempio. Infine cancella la coda rimanente; vedere il risultato di Anatomia nel gioco.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var mobile = Asc(UO.GetSerial("lasttarget"), 0);
    if (Truth(mobile <= 0) || Truth(mobile >= 0x40000000) || !(Truth(UO.Exists(mobile))))
    {
        return null;
    }

    UO.CancelWaitTarget();
    try
    {
        UO.WaitTargetObject(mobile);
        if (Truth(UO.UseSkill("Anatomy")))
        {
            await Delay(1500);
        }
    }
    finally
    {
        UO.CancelWaitTarget();
    }

    return null;
}

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

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. Meditazione e osservazione del mana - Lezione di script

Parametri e flusso di esecuzione:

La meditazione viene invocata senza uno scopo. prima di immagazzinare il mana precedente, 2000 è il periodo di osservazione. La crescita del mana può avere altri motivi; Questa non è una prova di meditazione o una promessa di un tasso fisso di recupero.

Competenze

Abilità

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()
    {
        if (!(Truth(UO.Connected())) || Truth(UO.Dead()))
        {
            return null;
        }

        var before = UO.Mana();
        if (!(Truth(UO.UseSkill("Meditation"))))
        {
            UO.Print("Meditation request rejected");
            return null;
        }

        await Delay(2000);
        if (Truth(UO.Mana() > before))
        {
            UO.Print("Mana increased");
        }
        else
        {
            UO.Print("No mana increase observed yet");
        }

        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.UseSkill(skillName)` — `UO.UseSkill(String)`

Parametri: skillName (String)

Risultato: int / Integer.

Durante la chiamata:

InjectionScript.Runtime.InjectionApiUO.UseSkill.
InjectionScript.Runtime.InjectionApiUO.UseSkillCore: UseSkillCore(skillName).

Codice interno di implementazione; non è uno script autonomo.

public int UseSkill(string skillName)

        {

            return UseSkillCore(skillName) ? 1 : 0;

        }

IT UO Topic skills - LIHACHTETAN/ClassicUO-Bad-Newbie-CSharp-Scripts-IDE GitHub Wiki

Competenze

Abilità: nomi e numeri esatti

Sezioni

Tutti i comandi del tema

Competenze

Esempi sull'argomento

UO.UseSkill

UO.GetSkillValue

Riferimento completo dei comandi

UO.GetSkillCap

Firme C#

Parametri

Valore restituito

Comportamento

Script C# autonomi

Esempio semplice

1. Lettura e output: script diretto

2. Applica in condizione o confronto - funzione script

3. Funzione di supporto completa: classe di script

Competenze

Implementazione del comando

UO.GetSkillCap(skillName) — UO.GetSkillCap(Any)

UO.GetSkillCurrentValue

Firme C#

Parametri

Valore restituito

Comportamento

Script C# autonomi

Esempio semplice

1. Lettura e output: script diretto

2. Applica in condizione o confronto - funzione script

3. Funzione di supporto completa: classe di script

Competenze

Implementazione del comando

UO.GetSkillCurrentValue(skillName) — UO.GetSkillCurrentValue(Any)

UO.GetSkillLockState

Firme C#

Parametri

Valore restituito

Comportamento

Script C# autonomi

Esempio semplice

1. Lettura e output: script diretto

2. Applica in condizione o confronto - funzione script

3. Funzione di supporto completa: classe di script

Competenze

Implementazione del comando

UO.GetSkillLockState(skillName) — UO.GetSkillLockState(Any)

UO.GetSkillValue

Firme C#

Parametri

Valore restituito

Comportamento

Script C# autonomi

Esempio semplice

1. Lettura e output: script diretto

2. Applica in condizione o confronto - funzione script

3. Funzione di supporto completa: classe di script

Competenze

Implementazione del comando

UO.GetSkillValue(skillName) — UO.GetSkillValue(Any)

UO.SetSkillLockState

Firme C#

Parametri

Valore restituito

Comportamento

Script C# autonomi

Esempio semplice

1. Lettura e output: script diretto

2. Applica in condizione o confronto - funzione script

3. Funzione di supporto completa: classe di script

Competenze

Implementazione del comando

UO.SetSkillLockState(skillName, skillState) — UO.SetSkillLockState(Any,Any)

UO.SkillLockState

Firme C#

Parametri

Valore restituito

Comportamento

`UO.GetSkillCap(skillName)` — `UO.GetSkillCap(Any)`

`UO.GetSkillCurrentValue(skillName)` — `UO.GetSkillCurrentValue(Any)`

`UO.GetSkillLockState(skillName)` — `UO.GetSkillLockState(Any)`

`UO.GetSkillValue(skillName)` — `UO.GetSkillValue(Any)`

`UO.SetSkillLockState(skillName, skillState)` — `UO.SetSkillLockState(Any,Any)`

`UO.SkillLockState(skillName, skillState)` — `UO.SkillLockState(Any,Any)`

`UO.SkillVal(skillName)` — `UO.SkillVal(String)`

`UO.SkillVal(skill, variant)` — `UO.SkillVal(Any,Any)`

`UO.Snoop()` — `UO.Snoop()`

`UO.Snoop(container)` — `UO.Snoop(Any)`

`UO.StealthCnt()` — `UO.StealthCnt()`

`UO.TicksSkill()` — `UO.TicksSkill()`