IT UO Topic scripts runtime

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

Script e tempo di esecuzione

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

Avvia, metti in pausa, interrompi script e procedure, informazioni sull'istanza, eventi e attesa. Terminate e StopScript operano a diversi livelli di esecuzione.

Sezioni

Argomento	Comandi e spiegazioni
StartScript	UO.StartScript
StopScript	UO.StopScript
StopAllScripts	UO.StopAllScripts
PauseResumeScript	UO.PauseResumeScript
Script State	UO.GetScriptState
Script List	UO.GetScriptsList · UO.GetScriptsCount
Script Name	UO.GetScriptName · UO.SetScriptName
Script Path	UO.GetScriptPath
CallSub	UO.CallSub
SubExists	UO.SubExists
Events	UO.SetEvent · UO.SetEventProc
Timers	UO.Timer · UO.Wait
Disconnect Behaviour	UO.GetPauseScriptOnDisconnectStatus · UO.SetPauseScriptOnDisconnectStatus

Tutti i comandi del tema

Ciclo di vita dello script

UO.StartScript · UO.StopScript · UO.StopAllScripts · UO.PauseResumeScript · UO.GetScriptName · UO.SetScriptName · UO.GetScriptPath · UO.GetScriptsCount · UO.GetScriptsList · UO.GetScriptState · UO.Exec · UO.Launch

Procedure/Eventi

UO.CallSub · UO.SubExists · UO.FunRunning · UO.Terminate · UO.TerminateAll · UO.SetEvent · UO.SetEventProc

Temporizzatori / Waiting

UO.Wait · UO.Waiting · UO.Timer · UO.Time · UO.Date

Disconnect Comportamento

UO.GetPauseScriptOnDisconnectStatus · UO.SetPauseScriptOnDisconnectStatus

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

Parametri, risultato e tutti gli scenari

var indices = UO.GetScriptsList();
foreach (var index in indices)
{
    UO.Print(Convert.ToString(index) + ": " + UO.GetScriptName(index));
}

UO.TerminateAll

Parametri, risultato e tutti gli scenari

for (int cycle = (int)(1); cycle <= 10; cycle += (int)(1))
{
    if (Truth(UO.Dead()))
    {
        UO.Print("Character is dead: stopping all C# scripts");
        UO.TerminateAll();
    }
    await Delay(250);
}

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;

Riferimento completo dei comandi

---

UO.CallSub

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

Firme C#

void UO.CallSub(object? subrutineName);

Avvia il delegato C# precedentemente registrato nell'esecuzione corrente tramite RegisterRoutine(nome, gestore). La chiamata restituisce il controllo prima che l'aiutante completi; Un'attività registrata non può essere imposta su se stessa.

Parametri

• subrutineName è il nome della stringa dato da RegisterRoutine. Lo spazio bianco attorno ai bordi viene rimosso; Le ricerche di nomi registrati non fanno distinzione tra maiuscole e minuscole.

Valore restituito

void - nessun risultato; un nome sconosciuto CallSub causa un errore e la riesecuzione di un nome già attivo viene saltata.

Comportamento

UO.FunRunning(name) == 0 può verificarsi anche subito dopo una richiesta di annullamento. Non significa che il callback precedente abbia terminato il blocco finally. Un altro CallSub o Exec con lo stesso nome locale viene ignorato finché il worker precedente non termina davvero.

• La registrazione e le attività appartengono alla stessa esecuzione. Un altro personaggio, profilo o esecuzione successiva ha il proprio registro.
• RegisterRoutine accetta Action, Func<Task> o un delegato con un array di argomenti stringa su Exec. La rimozione della registrazione non esegue il codice e impedisce ulteriori ricerche del nome.
• Lo script principale deve rimanere attivo finché sono necessari i suoi aiutanti: una volta completato, le attività vengono cancellate e le registrazioni e gli abbonamenti vengono rilasciati.
• FunRunning non è un indice di gestione. GetScriptsList e GetScriptState descrivono lanci di file indipendenti; la richiamata locale non riceve un indice separato.
• L'errore di callback viene passato allo script principale al controllo successivo. I loop WaitAsync, UO.Wait e C# strumentati supportano la pausa, l'annullamento e l'elaborazione della coda degli eventi.

File C# caricati

Oltre ai delegati locali, l'attuale gestore supporta voci C# caricate esplicitamente con una chiave come Child.csx::Main. SubExists e FunRunning accettano tale chiave; CallSub esegue il file senza Args e Exec("exec Child.csx::Main 'north gate' 42") passa Args. La chiave con spazi è racchiusa tra virgolette all'interno di Exec. È accettabile un nome breve univoco, un nome ambiguo non seleziona un file casuale. La registrazione locale ha la precedenza. Il lancio di un file ottiene il proprio contesto e la propria durata nel mondo/manager attuale; i delegati locali appartengono all'esecuzione che li ha registrati.

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.

RegisterRoutine("Hello", () => UO.Print("Hello from a routine"));
UO.CallSub("Hello");
while (UO.FunRunning("Hello") != 0) await WaitAsync(25);

1. Avvia Observer e continua Main - script diretto

Parametri e flusso di esecuzione:

• WeightWatch è il nome della procedura seguente. Ritorni principali 77 senza attendere tre campioni; 77 è il risultato di Main, non CallSub.
• Salva l'esempio come file separato, caricalo in IDE/manager ed esegui Main in modo che il resto delle procedure finisca nella directory. WeightWatch/ManaWatch - procedure di addestramento completamente definite qui: tre misurazioni di peso/mana con un intervallo di UO.Wait(1000), cioè 1000 ms, emesse solo quando si entra nel mondo. Non si tratta di un monitoraggio continuo; una pausa può prolungare il tempo. Nell'esempio con due task deve essere consentito l'avvio simultaneo delle procedure.

var registrationWeightWatch = RegisterRoutine("WeightWatch", WeightWatch);
UO.CallSub("WeightWatch");
while (UO.FunRunning("WeightWatch") != 0) await WaitAsync(25);
return 77;

void WeightWatch()
{
    dynamic sample = 0;
    for (sample = (int)(1); sample <= 3; sample += (int)(1))
    {
        if (Truth(UO.Connected()))
        {
            UO.Print("Weight: " + Convert.ToString(UO.Weight()));
        }
        UO.Wait(1000);
    }
}

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

2. Non riavviare un'attività attiva o sospesa - funzione script

Parametri e flusso di esecuzione:

• StartIfIdle controlla prima la definizione, poi l'attività. false significa che la richiesta non è stata inviata. true significa che è stata inviata solo la richiesta CallSub, non la conferma di inizio o completamento.
• Salva l'esempio come file separato, caricalo in IDE/manager ed esegui Main in modo che il resto delle procedure finisca nella directory. WeightWatch/ManaWatch - procedure di addestramento completamente definite qui: tre misurazioni di peso/mana con un intervallo di UO.Wait(1000), cioè 1000 ms, emesse solo quando si entra nel mondo. Non si tratta di un monitoraggio continuo; una pausa può prolungare il tempo. Nell'esempio con due task deve essere consentito l'avvio simultaneo delle procedure.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var registrationWeightWatch = RegisterRoutine("WeightWatch", WeightWatch);
    var launched = StartIfIdle("WeightWatch");
    while (UO.FunRunning("WeightWatch") != 0)
        await WaitAsync(25);
    return launched;
    return null;
}

dynamic StartIfIdle(dynamic name)
{
    if (!(Truth(UO.SubExists(name))))
    {
        return false;
    }

    if (Truth(UO.FunRunning(name)))
    {
        return false;
    }

    UO.CallSub(name);
    return true;
}

void WeightWatch()
{
    dynamic sample = 0;
    for (sample = (int)(1); sample <= 3; sample += (int)(1))
    {
        if (Truth(UO.Connected()))
        {
            UO.Print("Weight: " + Convert.ToString(UO.Weight()));
        }

        UO.Wait(1000);
    }
}

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

3. Due osservatori indipendenti - Classe di scenari

Parametri e flusso di esecuzione:

• Il primo CallSub inizia WeightWatch, il secondo - ManaWatch. Le corse sono indipendenti e non scambiano variabili locali; l'ordine della loro uscita non è garantito.
• Salva l'esempio come file separato, caricalo in IDE/manager ed esegui Main in modo che il resto delle procedure finisca nella directory. WeightWatch/ManaWatch - procedure di addestramento completamente definite qui: tre misurazioni di peso/mana con un intervallo di UO.Wait(1000), cioè 1000 ms, emesse solo quando si entra nel mondo. Non si tratta di un monitoraggio continuo; una pausa può prolungare il tempo. Nell'esempio con due task deve essere consentito l'avvio simultaneo delle procedure.

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 registrationWeightWatch = RegisterRoutine("WeightWatch", WeightWatch);
        var registrationManaWatch = RegisterRoutine("ManaWatch", ManaWatch);
        UO.CallSub("WeightWatch");
        UO.CallSub("ManaWatch");
        while (UO.FunRunning("WeightWatch") != 0 || UO.FunRunning("ManaWatch") != 0)
            await WaitAsync(25);
        return null;
    }

    void WeightWatch()
    {
        dynamic sample = 0;
        for (sample = (int)(1); sample <= 3; sample += (int)(1))
        {
            if (Truth(UO.Connected()))
            {
                UO.Print("Weight: " + Convert.ToString(UO.Weight()));
            }

            UO.Wait(1000);
        }
    }

    void ManaWatch()
    {
        dynamic sample = 0;
        for (sample = (int)(1); sample <= 3; sample += (int)(1))
        {
            if (Truth(UO.Connected()))
            {
                UO.Print("Mana: " + Convert.ToString(UO.Mana()));
            }

            UO.Wait(1000);
        }
    }

    bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
    private IDisposable RegisterRoutine(string name, Action handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Action<string[]> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<string[], Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
}

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.CallSub(subrutineName) — UO.CallSub(String)

Parametri: subrutineName (String)

Risultato: void / Unit.

Durante la chiamata:

• ClassicUO.CSharp.CSharpCallbacks.TryInvoke.
• InjectionScript.Runtime.InjectionApiUO.CallSub.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Exec: bridge.Exec(subrutineName).

Codice interno di implementazione; non è uno script autonomo.

case "CallSub":
                string called = Convert.ToString(arguments[0]) ?? "";
                if (Exists(called)) Start(called);
                else if (events is ICSharpScriptHost host && host.HasCSharpScript(called)) host.ExecuteCSharpScript("exec \"" + called + "\"");
                else throw new ArgumentException($"Register the C# routine or load a C# script entry named '{called}' before calling it.");
                return true;

Codice interno di implementazione; non è uno script autonomo.

public void CallSub(string subrutineName) => bridge.Exec(subrutineName);

---

UO.Date

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

Firme C#

int UO.Date();

Legge la data del calendario locale del computer con il numero YYMMDD. Utile per nominare una serie di attività giornaliere o rilevare cambiamenti di data.

Parametri

Non ci sono parametri.

Valore restituito

int YYMMDD: 2026-09-30 -> 260930. Non sono memorizzati delimitatori o zeri iniziali. Non è la durata, non è il tempo di Unix e non è true/false.

Comportamento

• Non ci sono parametri, né moduli con argomenti. Le parentesi vuote leggono solo l'ora: la chiamata non attende, non avvia un timer o non invia pacchetti al gioco.
• RealTimeSource.Ora si legge DateTime.Ora: la data/ora locale del computer, non UTC, non l'ora dello shard e non l'orologio del gioco. Il fuso orario, l'ora legale e il cambio manuale dell'orologio influiscono sui risultati. Ogni chiamata cattura un momento diverso.
• Vengono conservate solo le ultime due cifre dell'anno: sia 2000-01-01 che 2100-01-01 danno 101. Secoli diversi non sono diversi. Le chiamate individuali Date e Time possono arrivare su lati opposti della mezzanotte.
• Non sottrarre i codici del calendario per calcolare il ritardo. Usa Timer() e due segni di una corsa. L'orologio del calendario potrebbe tornare indietro.

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

1. Assegna un nome alla serie di raccolta delle risorse giornaliere: script diretto

Parametri e flusso di esecuzione:

• Il risultato della chiamata senza parametri viene salvato una volta. sessionLabel è una stringa come Harvest-260930. Print mostra solo il nome: il file non viene creato, la raccolta delle risorse non viene avviata.

var dateStamp = UO.Date();
var sessionLabel = "harvest-" + Convert.ToString(dateStamp);
UO.Print(sessionLabel);

2. Termina la serie quando cambia il giorno locale - funzione script

Parametri e flusso di esecuzione:

• originalDate memorizza la data originale. Timer limita l'osservazione a 60 secondi, UO.Wait(1000) controlla circa una volta al secondo. La modifica della data termina Principale. L'esempio non attende la mezzanotte per un tempo indefinito e non afferma che il giorno sia cambiato sul server.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var originalDate = UO.Date();
    var started = Environment.TickCount;
    while (Truth(Environment.TickCount - started < 60.0))
    {
        if (Truth(UO.Date() != originalDate))
        {
            UO.Print("Local date changed; end this batch");
            return null;
        }

        await Delay(1000);
    }

    UO.Print("No date change observed within one minute");
    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. Seleziona anno, mese e giorno - lezione di script

Parametri e flusso di esecuzione:

• MonthPart(timbro) viene mostrato per intero: divisione arrotondata per difetto e MOD 100 estrae il mese. giorno: ultime due cifre; shortYear—anno incompleto. Per 260930 otteniamo 26, 9, 30.

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 stamp = UO.Date();
        var month = MonthPart(stamp);
        var day = stamp % 100;
        var shortYear = stamp / 10000;
        UO.Print(Convert.ToString(shortYear) + "/" + Convert.ToString(month) + "/" + Convert.ToString(day));
        return null;
    }

    dynamic MonthPart(dynamic stamp)
    {
        return stamp / 100 % 100;
    }
}

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

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.Date.

Codice interno di implementazione; non è uno script autonomo.

public int Date()

        {

            var now = timeSource.Now;

            return (now.Year % 100) * 10000 + now.Month * 100 + now.Day;

        }

---

UO.Exec

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

Firme C#

void UO.Exec(object? parameters);

Esegue un comando di gioco di testo o esegue un delegato C# registrato o un file C# caricato.

Parametri

• parameters - stringa di comando: ad esempio, "useskill Hiding", "exec Worker 42" o "exec Child.csx::Main 'north gate' 42". Un'espressione C# come 2+3 all'interno di una stringa non viene valutata automaticamente.

Valore restituito

void: nessun risultato. Restituire il controllo non significa la fine del lancio o la conferma dell'azione di gioco da parte del server.

Comportamento

UO.FunRunning(name) == 0 può verificarsi anche subito dopo una richiesta di annullamento. Non significa che il callback precedente abbia terminato il blocco finally. Un altro CallSub o Exec con lo stesso nome locale viene ignorato finché il worker precedente non termina davvero.

• Per prima cosa viene controllato il registro locale RegisterRoutine. Sono supportati "Name args", "exec Name args" e "_exec Name args". Il delegato riceve string[]: l'argomento 42 rimane la stringa "42" e '00123' mantiene gli zeri iniziali. Le virgolette singole o doppie concatenano un argomento con spazi; '' specifica una stringa vuota. Una citazione non chiusa causa un errore. In questo percorso, la barra rovesciata viene mantenuta alla lettera; Non utilizzare la sintassi di escape C# all'interno del testo del comando già scritto.
• Il delegato locale viene eseguito in modo asincrono. Per attendere che finisca, usa FunRunning e WaitAsync. Il riavvio del nome attivo non crea una copia e non rimuove la pausa. L'errore dell'helper viene passato allo script principale al checkpoint.
• Le voci dei file caricati esplicitamente vengono avviate dal gestore corrente con il proprio Args e la propria durata. La semplice accettazione della richiesta di avvio non significa che il file abbia finito di funzionare.
• I normali comandi di gioco vengono passati al dispatcher nativo. Qui vengono memorizzati i contratti dei parametri del corrispondente comando UO; Print/Msg/Say/ConsolePrint/TextPrint combina il resto della riga in testo. Per tipi ed espressioni C# precisi, utilizzare una chiamata diretta come UO.UseSkill("Hiding"). Un comando sconosciuto, argomenti non validi o virgolette possono causare il rilevamento di un'eccezione da parte di try/catch.
• Alias ​​della console: sayu → Say, closeuo → CloseHandle, CountOnGround → CountGround, clearignorelist → IgnoreReset, canceltarget → CancelTarget, cancelmove → MoveOff.

File C# caricati

Oltre ai delegati locali, l'attuale gestore supporta voci C# caricate esplicitamente con una chiave come Child.csx::Main. SubExists e FunRunning accettano tale chiave; CallSub esegue il file senza Args e Exec("exec Child.csx::Main 'north gate' 42") passa Args. La chiave con spazi è racchiusa tra virgolette all'interno di Exec. È accettabile un nome breve univoco, un nome ambiguo non seleziona un file casuale. La registrazione locale ha la precedenza. Il lancio di un file ottiene il proprio contesto e la propria durata nel mondo/manager attuale; i delegati locali appartengono all'esecuzione che li ha registrati.

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.

RegisterRoutine("Hello", () => UO.Print("Hello from a routine"));
UO.Exec("exec Hello");
while (UO.FunRunning("Hello") != 0) await WaitAsync(25);

1. Usa l'abilità selezionata - script diretto

Parametri e flusso di esecuzione:

• Nascondere è l'unico argomento per UseSkill. Entrando nel mondo, il cliente invia una richiesta per utilizzare l'abilità; il successo dell'occultamento è determinato dal server. Stessa operazione con chiamata diretta: UO.UseSkill("Hiding").

UO.Exec("useskill Hiding");

2. Passa l'etichetta della stringa alla procedura locale - funzione dello script

Parametri e flusso di esecuzione:

• SelectSavedRoute è definito di seguito e registra il nome del percorso selezionato. Le virgolette attorno a 00123 preservano gli zeri iniziali. Exec esegue il delegato registrato in modo asincrono. Il ciclo con FunRunning e WaitAsync attende esplicitamente che finisca, quindi lo script restituisce la stringa 00123. Questo è un salvataggio del nome dell'allenamento, non un comando di movimento.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var registration = RegisterRoutine("SelectSavedRoute", (Action<string[]>)(arguments =>
    {
        if (arguments.Length == 1)
            SelectSavedRoute(arguments[0]);
    }));
    UO.Exec("SelectSavedRoute '00123'");
    while (UO.FunRunning("SelectSavedRoute") != 0)
        await WaitAsync(25);
    return UO.GetGlobal("manual", "savedRoute");
    return null;
}

void SelectSavedRoute(dynamic name)
{
    UO.SetGlobal("manual", "savedRoute", name);
}

3. Esegui un osservatore separato - Classe script

Parametri e flusso di esecuzione:

• Esegui questo script C#: RegisterRoutine associa il nome WeightWatch alla funzione dichiarata dell'esecuzione corrente. exec WeightWatch avvia tre misurazioni del peso a intervalli 1000 ms e non ne attende il completamento. Lo script principale rimane attivo mentre l'assistente locale è in esecuzione; L'assistente non ha un indice manager separato. Se l'attività è già in pausa, Exec ancora una volta non la riprende.

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 registrationWeightWatch = RegisterRoutine("WeightWatch", WeightWatch);
        UO.Exec("exec WeightWatch");
        while (UO.FunRunning("WeightWatch") != 0)
            await WaitAsync(25);
        return null;
    }

    void WeightWatch()
    {
        dynamic sample = 0;
        for (sample = (int)(1); sample <= 3; sample += (int)(1))
        {
            if (Truth(UO.Connected()))
            {
                UO.Print("Weight: " + Convert.ToString(UO.Weight()));
            }

            UO.Wait(1000);
        }
    }

    bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
    private IDisposable RegisterRoutine(string name, Action handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Action<string[]> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<string[], Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
}

4. Carica lo script dalla cartella con spazi - script diretto

Parametri e flusso di esecuzione:

• Sostituisci il percorso con il file C# esistente con la tua procedura Main. startscript carica il file e chiede a Main di essere eseguito. Le virgolette appartengono al comando testuale; le barre rovesciate del percorso vengono mantenute. Vedere IDE per gli errori di avvio, poiché Exec non restituisce un riconoscimento.

UO.Exec("startscript 'C:\\UO Scripts\\Gather.csx'");

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.Exec(parameters) — UO.Exec(String)

Parametri: parameters (String)

Risultato: void / Unit.

Durante la chiamata:

• ClassicUO.CSharp.CSharpCallbacks.TryInvoke.
• InjectionScript.Runtime.InjectionRuntime.Exec.
• InjectionScript.Runtime.InjectionRuntime.Tokenize: Tokenize(parameters).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Exec: bridge.Exec(parts[1].Text).
• InjectionScript.Runtime.InjectionRuntime.TryHandleLegacyConsoleCommand: TryHandleLegacyConsoleCommand(command, rawArguments).
• InjectionScript.Runtime.InjectionRuntime.NormalizeConsoleAlias: NormalizeConsoleAlias(command).
• InjectionScript.Runtime.InjectionRuntime.IsRemainderTextCommand: IsRemainderTextCommand(command).
• InjectionScript.Runtime.InjectionRuntime.ToConsoleValue: ToConsoleValue(token.Text).
• InjectionScript.Runtime.InjectionRuntime.CallNativeSubrutine: CallNativeSubrutine(command, args).

Codice interno di implementazione; non è uno script autonomo.

case "Exec":
                var words = CommandWords(Convert.ToString(arguments[0]) ?? "");
                if (words.Length == 0) return false;
                int offset = words[0].Equals("exec", StringComparison.OrdinalIgnoreCase) || words[0].Equals("_exec", StringComparison.OrdinalIgnoreCase) ? 1 : 0;
                if (words.Length > offset && Exists(words[offset]))
                { Start(words[offset], words.Skip(offset + 1).ToArray()); return true; }
                if (words.Length > offset && events is ICSharpScriptHost scriptHost
                    && (offset == 1 || scriptHost.HasCSharpScript(words[offset])))
                {
                    string command = Convert.ToString(arguments[0]) ?? "";
                    if (words[0].Equals("_exec", StringComparison.OrdinalIgnoreCase)) command = "exec" + command.TrimStart()[5..];
                    scriptHost.ExecuteCSharpScript(command); return true;
                }
                return false;

Codice interno di implementazione; non è uno script autonomo.

public void Exec(string parameters)
        {
            ConsoleToken[] parts = Tokenize(parameters).ToArray();
            if (parts.Length == 0)
                return;

            string command = parts[0].Text;
            if (command.Equals("exec", StringComparison.OrdinalIgnoreCase))
            {
                if (parts.Length != 2 || string.IsNullOrWhiteSpace(parts[1].Text))
                    throw new NativeSubrutineException("Usage: exec script_function");
                bridge.Exec(parts[1].Text);
                return;
            }

            ConsoleToken[] arguments = parts.Skip(1).ToArray();
            string[] rawArguments = arguments.Select(token => token.Text).ToArray();
            if (TryHandleLegacyConsoleCommand(command, rawArguments))
                return;

            command = NormalizeConsoleAlias(command);
            if (IsRemainderTextCommand(command) && rawArguments.Length > 0)
                arguments = new[] { new ConsoleToken(string.Join(" ", rawArguments), true) };
            else if (command.Equals("ColorPrint", StringComparison.OrdinalIgnoreCase) && rawArguments.Length > 1)
                arguments = new[] { arguments[0], new ConsoleToken(string.Join(" ", rawArguments.Skip(1)), true) };
            else if (command.Equals("CharPrint", StringComparison.OrdinalIgnoreCase) && rawArguments.Length > 2)
                arguments = new[] { arguments[0], arguments[1], new ConsoleToken(string.Join(" ", rawArguments.Skip(2)), true) };

            InjectionValue[] args = arguments.Select(token => token.Quoted
                ? new InjectionValue(token.Text) : ToConsoleValue(token.Text)).ToArray();
            CallNativeSubrutine(command, args);
        }

---

UO.FunRunning

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

Firme C#

int UO.FunRunning(object? subrutineName);

Controlla se viene eseguita la richiamata C# registrata con il nome specificato. Risultato 1 abilita la pausa manuale; un'attività completata o annullata dà 0.

Parametri

• subrutineName è il nome della stringa dato da RegisterRoutine. Lo spazio bianco attorno ai bordi viene rimosso; Le ricerche di nomi registrati non fanno distinzione tra maiuscole e minuscole.

Valore restituito

int: 1 - la condizione è soddisfatta, 0 - non soddisfatta. Salva il risultato di una chiamata se sono necessari più controlli.

Comportamento

UO.FunRunning(name) == 0 può verificarsi anche subito dopo una richiesta di annullamento. Non significa che il callback precedente abbia terminato il blocco finally. Un altro CallSub o Exec con lo stesso nome locale viene ignorato finché il worker precedente non termina davvero.

• La registrazione e le attività appartengono alla stessa esecuzione. Un altro personaggio, profilo o esecuzione successiva ha il proprio registro.
• RegisterRoutine accetta Action, Func<Task> o un delegato con un array di argomenti stringa su Exec. La rimozione della registrazione non esegue il codice e impedisce ulteriori ricerche del nome.
• Lo script principale deve rimanere attivo finché sono necessari i suoi aiutanti: una volta completato, le attività vengono cancellate e le registrazioni e gli abbonamenti vengono rilasciati.
• FunRunning non è un indice di gestione. GetScriptsList e GetScriptState descrivono lanci di file indipendenti; la richiamata locale non riceve un indice separato.
• L'errore di callback viene passato allo script principale al controllo successivo. I loop WaitAsync, UO.Wait e C# strumentati supportano la pausa, l'annullamento e l'elaborazione della coda degli eventi.

File C# caricati

Oltre ai delegati locali, l'attuale gestore supporta voci C# caricate esplicitamente con una chiave come Child.csx::Main. SubExists e FunRunning accettano tale chiave; CallSub esegue il file senza Args e Exec("exec Child.csx::Main 'north gate' 42") passa Args. La chiave con spazi è racchiusa tra virgolette all'interno di Exec. È accettabile un nome breve univoco, un nome ambiguo non seleziona un file casuale. La registrazione locale ha la precedenza. Il lancio di un file ottiene il proprio contesto e la propria durata nel mondo/manager attuale; i delegati locali appartengono all'esecuzione che li ha registrati.

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.

RegisterRoutine("Hello", async () => await WaitAsync(100));
UO.CallSub("Hello");
UO.Print("Running flag: " + UO.FunRunning("Hello"));
while (UO.FunRunning("Hello") != 0) await WaitAsync(25);

1. Esegui osservatore registrato senza sovrapposizione - script diretto

Parametri e flusso di esecuzione:

• Innanzitutto, RegisterRoutine associa il nome alla funzione C#. FunRunning controlla il compito di questa esecuzione, inclusa la pausa. Lo script principale rimane attivo fino al completamento dell'helper.

var registration = RegisterRoutine("WeightWatch", WatchWeight);
if (UO.FunRunning("WeightWatch") == 0) UO.CallSub("WeightWatch");
while (UO.FunRunning("WeightWatch") != 0) await WaitAsync(25);

async Task WatchWeight()
{
    for (int sample = 0; sample < 3; sample++)
    {
        UO.Print($"Weight: {UO.Weight()}");
        await WaitAsync(250);
    }
}

2. Attendi il completamento e leggi il risultato del lavoro in background - funzione script

Parametri e flusso di esecuzione:

• Il delegato asincrono modifica il contatore condiviso tramite Interlocked. Dopo FunRunning=0 il risultato viene letto attraverso Volatile. Questa è una richiamata locale; non ha un indice separato GetScriptsList.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    int completed = 0;
    var registration = RegisterRoutine("Worker", async () =>
    {
        await WaitAsync(150);
        Interlocked.Exchange(ref completed, 1);
    });
    UO.CallSub("Worker");
    UO.Print($"Worker active: {UO.FunRunning("Worker") != 0}");
    while (UO.FunRunning("Worker") != 0)
        await WaitAsync(25);
    return Volatile.Read(ref completed) == 1;
    return null;
}

3. Annulla l'helper asincrono registrato - classe di script

Parametri e flusso di esecuzione:

• Terminate seleziona l'attività registrata dell'esecuzione corrente. In attesa che WaitAsync utilizzi il suo token di cancellazione. finally esegue la pulizia; non sono consentite ulteriori azioni di gioco dell'attività annullata.

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()
    {
        int cleanupDone = 0;
        var registration = RegisterRoutine("Worker", async () =>
        {
            try
            {
                await WaitAsync(5000);
            }
            finally
            {
                Interlocked.Exchange(ref cleanupDone, 1);
            }
        });
        UO.CallSub("Worker");
        await WaitAsync(100);
        if (UO.FunRunning("Worker") != 0)
            UO.Terminate("Worker");
        while (UO.FunRunning("Worker") != 0)
            await WaitAsync(25);
        while (Volatile.Read(ref cleanupDone) == 0)
            await WaitAsync(25);
        return true;
        return null;
    }

    private IDisposable RegisterRoutine(string name, Action handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Action<string[]> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<string[], Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
}

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.FunRunning(subrutineName) — UO.FunRunning(String)

Parametri: subrutineName (String)

Risultato: int / Integer.

Durante la chiamata:

• ClassicUO.CSharp.CSharpCallbacks.TryInvoke.
• InjectionScript.Runtime.InjectionApiUO.FunRunning.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.FunRunning: bridge.FunRunning(subrutineName).

Codice interno di implementazione; non è uno script autonomo.

case "FunRunning":
                string runningName = Convert.ToString(arguments[0]) ?? "";
                result = IsRunning(runningName) || events is ICSharpScriptHost runningHost && runningHost.IsCSharpScriptRunning(runningName) ? 1 : 0;
                return true;

Codice interno di implementazione; non è uno script autonomo.

public int FunRunning(string subrutineName) => bridge.FunRunning(subrutineName) ? 1 : 0;

---

UO.GetPauseScriptOnDisconnectStatus

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

Firme C#

dynamic UO.GetPauseScriptOnDisconnectStatus();

Legge l'impostazione di pausa dello script quando il gestore è disabilitato.

Parametri

Non ci sono parametri.

Valore restituito

int 1 — PauseScriptsOnDisconnect abilitato; 0 - disabilitato.

Comportamento

• Legge il flag del manager, non la pausa corrente di un singolo script. La chiamata in sé non viene messa in pausa né riattivata.

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

1. Impostazioni di lettura: script diretto

Parametri e flusso di esecuzione:

• Il valore descrive l'impostazione del gestore.

var enabled = UO.GetPauseScriptOnDisconnectStatus();
UO.Print(Convert.ToString(enabled));

2. Controllare separatamente la connessione - funzione script

Parametri e flusso di esecuzione:

• Il flag di configurazione e la connessione vengono letti in modo indipendente.

return  RunScenario();
 object? RunScenario()
{
    var pauseOnDisconnect = UO.GetPauseScriptOnDisconnectStatus();
    var online = UO.Connected();
    UO.Print(Convert.ToString(pauseOnDisconnect) + " " + Convert.ToString(online));
    return null;
}

3. Salva valore: classe di script

Parametri e flusso di esecuzione:

• La variabile contiene un'istantanea dell'impostazione al momento della lettura.

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 saved = UO.GetPauseScriptOnDisconnectStatus();
        await Delay(100);
        UO.Print(Convert.ToString(saved));
        return null;
    }

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

Parametri: Nessun parametro.

Risultato: dynamic / Any.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "getpausescriptondisconnectstatus": return new InjectionValue(bridge.GetPauseScriptOnDisconnectStatus());

---

UO.GetScriptName

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

Firme C#

string UO.GetScriptName(object? scriptIndex);

Legge il nome visualizzato della corsa attiva.

Parametri

• scriptIndex - Obbligatorio ScriptIndex - intero, indice da zero a fresco GetScriptsList. Per un indice negativo o mancante, viene restituito il risultato vuoto/sconosciuto descritto. Non passare serial dell'oggetto, il nome della procedura, o ID del lancio da IDE.

Valore restituito

string: nome visualizzato o "" se non è presente alcun indice. Un lancio esistente può anche avere il nome esplicitamente impostato su una stringa vuota.

Comportamento

• Vengono presi in considerazione i lanci in corso e quelli in pausa; sono esclusi quelli completati e che hanno ricevuto richiesta di cancellazione. Uno script in esecuzione solitamente tiene conto di se stesso. Il semplice caricamento della scheda IDE non è considerato un lancio.
• Gli indici sono le posizioni correnti nell'ordine di avvio. L'avvio/l'arresto degli script può spostare le posizioni. Chiamate diverse non formano un'istantanea atomica comune; rileggere l'elenco prima del successivo comando di controllo.
• GetScriptsList fornisce gli indici, GetScriptsCount la quantità, GetScriptState il codice dei tre stati. Non sostituire l'uno con l'altro né trattare qualsiasi risultato diverso da zero come il valore di true.
• ScriptIndex=0 - il primo lancio corrente, che non necessariamente richiama lo script. SetScriptName modifica il nome visualizzato senza rinominare il file.

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

1. Prima chiamata e risultato: script diretto

Parametri e flusso di esecuzione:

• Esegui lo script C# fornito. Il numero 0, dove viene passato, denota l'indice; le parentesi vuote non significano argomenti. Il testo Print è solo un messaggio di esempio.
• ScriptIndex=0 - il primo lancio corrente, che non necessariamente richiama lo script. SetScriptName modifica il nome visualizzato senza rinominare il file.
• string: nome visualizzato o "" se non è presente alcun indice. Un lancio esistente può anche avere il nome esplicitamente impostato su una stringa vuota.
• Obbligatorio ScriptIndex è un numero intero, indice da zero dal nuovo GetScriptsList. Per un indice negativo o mancante, viene restituito il risultato vuoto/sconosciuto descritto. Non passare serial dell'oggetto, il nome della procedura, o ID del lancio da IDE.

var index = 0;
var name = UO.GetScriptName(index);
UO.Print(name);

2. Utilizzare in un ciclo o in una condizione: funzione dello script

Parametri e flusso di esecuzione:

• This is a specific example of command sharing. Array indexing starts from zero; Please check the length before handling. UO.Wait(250), dove viene utilizzato, attende 250 millisecondi.
• ScriptIndex=0 - il primo lancio corrente, che non necessariamente richiama lo script. SetScriptName modifica il nome visualizzato senza rinominare il file.
• string: nome visualizzato o "" se non è presente alcun indice. Un lancio esistente può anche avere il nome esplicitamente impostato su una stringa vuota.
• Obbligatorio ScriptIndex è un numero intero, indice da zero dal nuovo GetScriptsList. Per un indice negativo o mancante, viene restituito il risultato vuoto/sconosciuto descritto. Non passare serial dell'oggetto, il nome della procedura, o ID del lancio da IDE.

return  RunScenario();
 object? RunScenario()
{
    var indices = UO.GetScriptsList();
    foreach (var index in indices)
    {
        var name = UO.GetScriptName(index);
        UO.Print(Convert.ToString(index) + " = " + name);
    }

    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

• Sotto Main c'è l'intera funzione. I suoi parametri e il risultato sono spiegati separatamente dal comando API che richiama.
• DescribeScript controlla lo stato e concatena il nome con il percorso. È possibile fare una pausa tra le chiamate; "mancante" è il valore della nostra funzione, non il risultato di GetScriptName.
• string: nome visualizzato o "" se non è presente alcun indice. Un lancio esistente può anche avere il nome esplicitamente impostato su una stringa vuota.
• Obbligatorio ScriptIndex è un numero intero, indice da zero dal nuovo GetScriptsList. Per un indice negativo o mancante, viene restituito il risultato vuoto/sconosciuto descritto. Non passare serial dell'oggetto, il nome della procedura, o ID del lancio da IDE.

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.Print(DescribeScript(0));
        return null;
    }

    dynamic DescribeScript(dynamic index)
    {
        if (Truth(UO.GetScriptState(index) == 0))
        {
            return "missing";
        }

        return UO.GetScriptName(index) + " | " + UO.GetScriptPath(index);
    }

    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.GetScriptName(scriptIndex) — UO.GetScriptName(Any)

Parametri: scriptIndex (Any)

Risultato: string / String.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "getscriptname": return new InjectionValue(bridge.GetScriptName(Arg(0)));

---

UO.GetScriptPath

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

Firme C#

string UO.GetScriptPath(object? scriptIndex);

Legge il percorso del file di origine di avvio attivo.

Parametri

• scriptIndex - Obbligatorio ScriptIndex - intero, indice da zero a fresco GetScriptsList. Per un indice negativo o mancante, viene restituito il risultato vuoto/sconosciuto descritto. Non passare serial dell'oggetto, il nome della procedura, o ID del lancio da IDE.

Valore restituito

string: percorso salvato del file sorgente o "" se non è presente alcun indice. Quando si esegue il file, solitamente si tratta del percorso completo; Il comando o l'origine potrebbero non avere un file normale in memoria.

Comportamento

• Vengono presi in considerazione i lanci in corso e quelli in pausa; sono esclusi quelli completati e che hanno ricevuto richiesta di cancellazione. Uno script in esecuzione solitamente tiene conto di se stesso. Il semplice caricamento della scheda IDE non è considerato un lancio.
• Gli indici sono le posizioni correnti nell'ordine di avvio. L'avvio/l'arresto degli script può spostare le posizioni. Chiamate diverse non formano un'istantanea atomica comune; rileggere l'elenco prima del successivo comando di controllo.
• GetScriptsList fornisce gli indici, GetScriptsCount la quantità, GetScriptState il codice dei tre stati. Non sostituire l'uno con l'altro né trattare qualsiasi risultato diverso da zero come il valore di true.
• ScriptIndex=0 seleziona la prima corsa corrente. Il risultato ne indica la fonte; il comando non apre, salva o esegue questo file.

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

1. Prima chiamata e risultato: script diretto

Parametri e flusso di esecuzione:

• Esegui lo script C# fornito. Il numero 0, dove viene passato, denota l'indice; le parentesi vuote non significano argomenti. Il testo Print è solo un messaggio di esempio.
• ScriptIndex=0 seleziona la prima corsa corrente. Il risultato ne indica la fonte; il comando non apre, salva o esegue questo file.
• string: percorso salvato del file sorgente o "" se non è presente alcun indice. Quando si esegue il file, solitamente si tratta del percorso completo; Il comando o l'origine potrebbero non avere un file normale in memoria.
• Obbligatorio ScriptIndex è un numero intero, indice da zero dal nuovo GetScriptsList. Per un indice negativo o mancante, viene restituito il risultato vuoto/sconosciuto descritto. Non passare serial dell'oggetto, il nome della procedura, o ID del lancio da IDE.

var index = 0;
var path = UO.GetScriptPath(index);
if (Truth(path!=""))
{
    UO.Print(path);
}

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

2. Utilizzare in un ciclo o in una condizione: funzione dello script

Parametri e flusso di esecuzione:

• This is a specific example of command sharing. Array indexing starts from zero; Please check the length before handling. UO.Wait(250), dove viene utilizzato, attende 250 millisecondi.
• ScriptIndex=0 seleziona la prima corsa corrente. Il risultato ne indica la fonte; il comando non apre, salva o esegue questo file.
• string: percorso salvato del file sorgente o "" se non è presente alcun indice. Quando si esegue il file, solitamente si tratta del percorso completo; Il comando o l'origine potrebbero non avere un file normale in memoria.
• Obbligatorio ScriptIndex è un numero intero, indice da zero dal nuovo GetScriptsList. Per un indice negativo o mancante, viene restituito il risultato vuoto/sconosciuto descritto. Non passare serial dell'oggetto, il nome della procedura, o ID del lancio da IDE.

return  RunScenario();
 object? RunScenario()
{
    var indices = UO.GetScriptsList();
    foreach (var index in indices)
    {
        UO.Print(UO.GetScriptName(index) + " -> " + UO.GetScriptPath(index));
    }

    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

• Sotto Main c'è l'intera funzione. I suoi parametri e il risultato sono spiegati separatamente dal comando API che richiama.
• ReadScriptPath sostituisce il parametro fallback solo se il percorso è vuoto. Questa è una funzione separata e non un nuovo sovraccarico GetScriptPath.
• string: percorso salvato del file sorgente o "" se non è presente alcun indice. Quando si esegue il file, solitamente si tratta del percorso completo; Il comando o l'origine potrebbero non avere un file normale in memoria.
• Obbligatorio ScriptIndex è un numero intero, indice da zero dal nuovo GetScriptsList. Per un indice negativo o mancante, viene restituito il risultato vuoto/sconosciuto descritto. Non passare serial dell'oggetto, il nome della procedura, o ID del lancio da IDE.

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.Print(ReadScriptPath(0, "path unavailable"));
        return null;
    }

    dynamic ReadScriptPath(dynamic index, dynamic fallback)
    {
        var path = UO.GetScriptPath(index);
        if (Truth(path == ""))
        {
            return fallback;
        }

        return path;
    }

    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.GetScriptPath(scriptIndex) — UO.GetScriptPath(Any)

Parametri: scriptIndex (Any)

Risultato: string / String.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "getscriptpath": return new InjectionValue(bridge.GetScriptPath(Arg(0)));

---

UO.GetScriptState

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

Firme C#

int UO.GetScriptState(object? scriptIndex);

Legge lo stato di esecuzione per indice.

Parametri

• scriptIndex - Obbligatorio ScriptIndex - intero, indice da zero a fresco GetScriptsList. Per un indice negativo o mancante, viene restituito il risultato vuoto/sconosciuto descritto. Non passare serial dell'oggetto, il nome della procedura, o ID del lancio da IDE.

Valore restituito

int — codice di stato: 0 = no/sconosciuto, 1 = in esecuzione, 2 = pausa. Questo non è un bool: confronta esplicitamente con 1 o 2.

Comportamento

• Vengono presi in considerazione i lanci in corso e quelli in pausa; sono esclusi quelli completati e che hanno ricevuto richiesta di cancellazione. Uno script in esecuzione solitamente tiene conto di se stesso. Il semplice caricamento della scheda IDE non è considerato un lancio.
• Gli indici sono le posizioni correnti nell'ordine di avvio. L'avvio/l'arresto degli script può spostare le posizioni. Chiamate diverse non formano un'istantanea atomica comune; rileggere l'elenco prima del successivo comando di controllo.
• GetScriptsList fornisce gli indici, GetScriptsCount la quantità, GetScriptState il codice dei tre stati. Non sostituire l'uno con l'altro né trattare qualsiasi risultato diverso da zero come il valore di true.
• Vengono prese in considerazione la pausa manuale/debug e la pausa di spegnimento configurata. Lo stato 1 non garantisce che lo script stia attualmente consumando CPU o ricevendo dati dal server.

Script C# autonomi

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

Esempio semplice

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

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

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

1. Prima chiamata e risultato: script diretto

Parametri e flusso di esecuzione:

• Esegui lo script C# fornito. Il numero 0, dove viene passato, denota l'indice; le parentesi vuote non significano argomenti. Il testo Print è solo un messaggio di esempio.
• Vengono prese in considerazione la pausa manuale/debug e la pausa di spegnimento configurata. Lo stato 1 non garantisce che lo script stia attualmente consumando CPU o ricevendo dati dal server.
• int — codice di stato: 0 = no/sconosciuto, 1 = in esecuzione, 2 = pausa. Questo non è un bool: confronta esplicitamente con 1 o 2.
• Obbligatorio ScriptIndex è un numero intero, indice da zero dal nuovo GetScriptsList. Per un indice negativo o mancante, viene restituito il risultato vuoto/sconosciuto descritto. Non passare serial dell'oggetto, il nome della procedura, o ID del lancio da IDE.

int state = UO.GetScriptState(0);
string text = state switch
{
    1 => "running",
    2 => "paused",
    _ => "unknown"
};
UO.Print(text);

2. Utilizzare in un ciclo o in una condizione: funzione dello script

Parametri e flusso di esecuzione:

• This is a specific example of command sharing. Array indexing starts from zero; Please check the length before handling. UO.Wait(250), dove viene utilizzato, attende 250 millisecondi.
• Vengono prese in considerazione la pausa manuale/debug e la pausa di spegnimento configurata. Lo stato 1 non garantisce che lo script stia attualmente consumando CPU o ricevendo dati dal server.
• int — codice di stato: 0 = no/sconosciuto, 1 = in esecuzione, 2 = pausa. Questo non è un bool: confronta esplicitamente con 1 o 2.
• Obbligatorio ScriptIndex è un numero intero, indice da zero dal nuovo GetScriptsList. Per un indice negativo o mancante, viene restituito il risultato vuoto/sconosciuto descritto. Non passare serial dell'oggetto, il nome della procedura, o ID del lancio da IDE.

return  RunScenario();
 object? RunScenario()
{
    var paused = 0;
    var indices = UO.GetScriptsList();
    foreach (var index in indices)
    {
        if (Truth(UO.GetScriptState(index) == 2))
        {
            paused += 1;
        }
    }

    UO.Print(Convert.ToString(paused));
    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:

• Sotto Main c'è l'intera funzione. I suoi parametri e il risultato sono spiegati separatamente dal comando API che richiama.
• IsScriptActive converte 1 e 2 in true e 0 in false. GetScriptState stesso restituisce ancora un codice di stato numerico.
• int — codice di stato: 0 = no/sconosciuto, 1 = in esecuzione, 2 = pausa. Questo non è un bool: confronta esplicitamente con 1 o 2.
• Obbligatorio ScriptIndex è un numero intero, indice da zero dal nuovo GetScriptsList. Per un indice negativo o mancante, viene restituito il risultato vuoto/sconosciuto descritto. Non passare serial dell'oggetto, il nome della procedura, o ID del lancio da IDE.

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(Truth(IsScriptActive(0)) == true))
        {
            UO.Print("running or paused");
        }
        else
        {
            UO.Print("not active");
        }

        return null;
    }

    dynamic IsScriptActive(dynamic index)
    {
        var state = UO.GetScriptState(index);
        return Truth(state == 1) || Truth(state == 2);
    }

    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.GetScriptState(scriptIndex) — UO.GetScriptState(Any)

Parametri: scriptIndex (Any)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "getscriptstate": return new InjectionValue(bridge.GetScriptState(Arg(0)));

---

UO.GetScriptsCount

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

Firme C#

int UO.GetScriptsCount();

Conta le esecuzioni attive in questo client.

Parametri

Non ci sono parametri.

Valore restituito

int >= 0: numero di esecuzioni attive, comprese quelle in pausa. Questa è una quantità, non un bool o un indice di script.

Comportamento

• Vengono presi in considerazione i lanci in corso e quelli in pausa; sono esclusi quelli completati e che hanno ricevuto richiesta di cancellazione. Uno script in esecuzione solitamente tiene conto di se stesso. Il semplice caricamento della scheda IDE non è considerato un lancio.
• Gli indici sono le posizioni correnti nell'ordine di avvio. L'avvio/l'arresto degli script può spostare le posizioni. Chiamate diverse non formano un'istantanea atomica comune; rileggere l'elenco prima del successivo comando di controllo.
• GetScriptsList fornisce gli indici, GetScriptsCount la quantità, GetScriptState il codice dei tre stati. Non sostituire l'uno con l'altro né trattare qualsiasi risultato diverso da zero come il valore di true.
• Non ci sono argomenti. Il conteggio non ordina l'elenco e non modifica lo stato delle esecuzioni.

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

1. Prima chiamata e risultato: script diretto

Parametri e flusso di esecuzione:

• Esegui lo script C# fornito. Il numero 0, dove viene passato, denota l'indice; le parentesi vuote non significano argomenti. Il testo Print è solo un messaggio di esempio.
• Non ci sono argomenti. Il conteggio non ordina l'elenco e non modifica lo stato delle esecuzioni.
• int >= 0: numero di esecuzioni attive, comprese quelle in pausa. Questa è una quantità, non un bool o un indice di script.

var count = UO.GetScriptsCount();
UO.Print(Convert.ToString(count));

2. Utilizzare in un ciclo o in una condizione: funzione dello script

Parametri e flusso di esecuzione:

• This is a specific example of command sharing. Array indexing starts from zero; Please check the length before handling. UO.Wait(250), dove viene utilizzato, attende 250 millisecondi.
• Non ci sono argomenti. Il conteggio non ordina l'elenco e non modifica lo stato delle esecuzioni.
• int >= 0: numero di esecuzioni attive, comprese quelle in pausa. Questa è una quantità, non un bool o un indice di script.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.GetScriptsCount();
    await Delay(250);
    var after = UO.GetScriptsCount();
    UO.Print(Convert.ToString(after - before));
    return null;
}

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

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

• Sotto Main c'è l'intera funzione. I suoi parametri e il risultato sono spiegati separatamente dal comando API che richiama.
• HasOtherScripts confronta il conteggio con 1: lo script chiamante occupa tipicamente una voce. A differenza di GetScriptsCount, la funzione helper restituisce true/false.
• int >= 0: numero di esecuzioni attive, comprese quelle in pausa. Questa è una quantità, non un bool o un indice di script.

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(HasOtherScripts()))
        {
            UO.Print("Other executions are active");
        }
        else
        {
            UO.Print("No other active executions");
        }

        return null;
    }

    dynamic HasOtherScripts()
    {
        var count = UO.GetScriptsCount();
        return count > 1;
    }

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

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "getscriptscount": return new InjectionValue(bridge.GetScriptsCount());

---

UO.GetScriptsList

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

Firme C#

dynamic UO.GetScriptsList();

Restituisce gli indici degli script numerici correnti.

Parametri

Non ci sono parametri.

Valore restituito

Array di int: indici 0..N-1 o un array vuoto. Gli elementi sono numeri, non nomi o voci di testo.

Comportamento

• Vengono presi in considerazione i lanci in corso e quelli in pausa; sono esclusi quelli completati e che hanno ricevuto richiesta di cancellazione. Uno script in esecuzione solitamente tiene conto di se stesso. Il semplice caricamento della scheda IDE non è considerato un lancio.
• Gli indici sono le posizioni correnti nell'ordine di avvio. L'avvio/l'arresto degli script può spostare le posizioni. Chiamate diverse non formano un'istantanea atomica comune; rileggere l'elenco prima del successivo comando di controllo.
• GetScriptsList fornisce gli indici, GetScriptsCount la quantità, GetScriptState il codice dei tre stati. Non sostituire l'uno con l'altro né trattare qualsiasi risultato diverso da zero come il valore di true.
• Non ci sono argomenti. Passa ogni numero al corrispondente getter del nome, percorso o stato. L'array risultante è uno snapshot separato; modificarlo non controlla gli script.

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

1. Prima chiamata e risultato: script diretto

Parametri e flusso di esecuzione:

• Esegui lo script C# fornito. Il numero 0, dove viene passato, denota l'indice; le parentesi vuote non significano argomenti. Il testo Print è solo un messaggio di esempio.
• Non ci sono argomenti. Passa ogni numero al corrispondente getter del nome, percorso o stato. L'array risultante è uno snapshot separato; modificarlo non controlla gli script.
• Array di int: indici 0..N-1 o un array vuoto. Gli elementi sono numeri, non nomi o voci di testo.

var indices = UO.GetScriptsList();
foreach (var index in indices)
{
    UO.Print(Convert.ToString(index) + ": " + UO.GetScriptName(index));
}

2. Utilizzare in un ciclo o in una condizione: funzione dello script

Parametri e flusso di esecuzione:

• This is a specific example of command sharing. Array indexing starts from zero; Please check the length before handling. UO.Wait(250), dove viene utilizzato, attende 250 millisecondi.
• Non ci sono argomenti. Passa ogni numero al corrispondente getter del nome, percorso o stato. L'array risultante è uno snapshot separato; modificarlo non controlla gli script.
• Array di int: indici 0..N-1 o un array vuoto. Gli elementi sono numeri, non nomi o voci di testo.

return  RunScenario();
 object? RunScenario()
{
    var indices = UO.GetScriptsList();
    if (Truth(ArrayLength(indices) > 0))
    {
        var firstIndex = indices[0];
        UO.Print(UO.GetScriptPath(firstIndex));
    }

    return null;
}

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

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

• Sotto Main c'è l'intera funzione. I suoi parametri e il risultato sono spiegati separatamente dal comando API che richiama.
• FindNamedScript scorre gli indici correnti e restituisce la prima corrispondenza esatta del nome visualizzato o -1. I nomi possono essere ripetuti, gli indici possono spostarsi in seguito.
• Array di int: indici 0..N-1 o un array vuoto. Gli elementi sono numeri, non nomi o voci di testo.

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 index = FindNamedScript("Mining");
        if (Truth(index >= 0))
        {
            UO.Print(Convert.ToString(index));
        }
        else
        {
            UO.Print("Name not found");
        }

        return null;
    }

    dynamic FindNamedScript(dynamic wanted)
    {
        var indices = UO.GetScriptsList();
        foreach (var index in indices)
        {
            if (Truth(UO.GetScriptName(index) == wanted))
            {
                return index;
            }
        }

        return -1;
    }

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

Parametri: Nessun parametro.

Risultato: dynamic / Array.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "getscriptslist": return new InjectionValue(bridge.GetScriptsList().Select(value => new InjectionValue(value)).ToArray());

---

UO.Launch

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

Firme C#

int UO.Launch(object? file);
int UO.Launch(object? file, object? parameters);
int UO.Launch(object? file, object? parameters, object? workingDirectory);
int UO.Launch(object? file, object? parameters, object? workingDirectory, object? hidden);

Parametri

• file — Percorso/nome obbligatorio del programma o documento; convertito in testo, gli spazi esterni vengono rimossi. Un valore vuoto fornisce 0 e un messaggio di errore. Per selezionare il programma esatto utilizzare il percorso completo; Non è necessario aggiungere virgolette esterne al file stesso.
• workingDirectory - Cartella di lavoro opzionale del processo. Se c'è un'omissione o una riga vuota, viene occupata la cartella dello script corrente. Se il runtime non dispone di tale cartella, bridge utilizza la cartella di lavoro corrente del client. Questa non è sempre la cartella del gioco o la cartella del client EXE.
• hidden — Valore booleano opzionale, predefinito false. true disabilita l'apertura tramite la shell del sistema operativo e richiede l'avvio senza una finestra della console; hai bisogno di un file eseguibile. false consente le associazioni di documenti. Il programma GUI stesso può ancora mostrare la sua finestra.

Valore restituito

int: 1 (true) se Process.Start ha restituito un oggetto processo; altrimenti 0 (false). In C# controlla risultato == 1 o risultato != 0; int non può essere direttamente paragonato a true. Questo non è PID, un codice di uscita o una conferma del completamento dei lavori. Se si verifica un'eccezione, viene emesso un errore e viene restituito 0. Quando si apre un documento tramite un programma già in esecuzione, il sistema operativo a volte non restituisce un nuovo processo: 0 in questo caso non dimostra che il documento non è stato aperto.

Comportamento

• Sono consentiti solo sovraccarichi da uno a quattro argomenti, nell'ordine specificato. Per specificare nascosto e lasciare la cartella di lavoro predefinita, passare una stringa vuota come terzo argomento. Le conversioni di file/parametri/workingDirectory in testo non verificano in anticipo l'esistenza del file.
• La cartella predefinita è determinata dallo script attualmente in esecuzione. Con hidden=true il percorso relativo del programma viene prima controllato rispetto a workingDirectory. La ricerca parziale e le associazioni del nome del sistema operativo sono specifiche del sistema; il percorso completo elimina l'ambiguità. Se la cartella o il programma di lavoro non è disponibile, l'avvio potrebbe non riuscire.
• Il processo esterno viene eseguito in modo indipendente. Launch non attende il completamento, non legge stdout/stderr e non lo termina quando lo script viene interrotto. true per nascosto è una richiesta di un metodo di lancio e non una garanzia dell'invisibilità di eventuali finestre. L'oggetto Process viene rilasciato dopo la richiesta; il programma in esecuzione continua a funzionare.

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

1. Apri un rapporto di mining già pronto: script diretto

Parametri e flusso di esecuzione:

• Posiziona il loot-report.txt esistente accanto allo script. Il sistema operativo lo apre con l'applicazione assegnata al file .txt. Main restituisce il risultato della richiesta Launch, non il contenuto del report e non la conferma della sua lettura.

var started = UO.Launch("loot-report.txt");
return started;

2. Passa il percorso con spazi all'editor - funzione dello script

Parametri e flusso di esecuzione:

• La cartella e il report devono esistere; sostituiscili con i tuoi. Chr(34) racchiude il percorso completo del report tra virgolette doppie all'interno degli argomenti. notepad.exe deve essere accessibile al sistema. false abilita la normale finestra dell'editor.

return  RunScenario();
 object? RunScenario()
{
    var report = "C:\\UO Scripts\\loot report.txt";
    var arguments = Chr(34) + report + Chr(34);
    return UO.Launch("notepad.exe", arguments, "C:\\UO Scripts", false);
    return null;
}

string Chr(object? value) => ((char)Convert.ToInt32(value)).ToString();

3. Preparare un elenco di registri locali senza una finestra della console: classe di script

Parametri e flusso di esecuzione:

• L'esempio di Windows esegue il cmd.exe integrato. Nella cartella dello script viene creato o sovrascritto log-files.txt con un elenco di *.logs. Un terzo argomento vuoto salva la cartella dello script, true nasconde la console. true da Main significa solo avvio: il file potrebbe non essere ancora pronto, e l'assenza di *.log o un errore dell'utilità non modifica il risultato già ottenuto Launch.

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 started = UO.Launch("cmd.exe", "/d /c dir /b *.log > log-files.txt", "", true);
        if (Truth(started == 0))
        {
            return false;
        }

        return true;
        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.Launch(file) — UO.Launch(Any)

Parametri: file (Any)

Risultato: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.Register [Launch].
• InjectionScript.Runtime.InjectionApiUO.CompactLaunch: CompactLaunch(values).

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

Codice interno di implementazione; non è uno script autonomo.

values => new InjectionValue(CompactLaunch(values))

UO.Launch(file, parameters) — UO.Launch(Any,Any)

Parametri: file (Any), parameters (Any)

Risultato: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.Register [Launch].
• InjectionScript.Runtime.InjectionApiUO.CompactLaunch: CompactLaunch(values).

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

Codice interno di implementazione; non è uno script autonomo.

values => new InjectionValue(CompactLaunch(values))

UO.Launch(file, parameters, workingDirectory) — UO.Launch(Any,Any,Any)

Parametri: file (Any), parameters (Any), workingDirectory (Any)

Risultato: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.Register [Launch].
• InjectionScript.Runtime.InjectionApiUO.CompactLaunch: CompactLaunch(values).

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

Codice interno di implementazione; non è uno script autonomo.

values => new InjectionValue(CompactLaunch(values))

UO.Launch(file, parameters, workingDirectory, hidden) — UO.Launch(Any,Any,Any,Any)

Parametri: file (Any), parameters (Any), workingDirectory (Any), hidden (Any)

Risultato: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.Register [Launch].
• InjectionScript.Runtime.InjectionApiUO.CompactLaunch: CompactLaunch(values).

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

Codice interno di implementazione; non è uno script autonomo.

values => new InjectionValue(CompactLaunch(values))

---

UO.PauseResumeScript

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

Firme C#

void UO.PauseResumeScript(object? scriptIndex);

Attiva/disattiva la pausa manuale di una corsa attiva. Utilizzare per interrompere temporaneamente l'estrazione o un'altra procedura senza perdere i progressi attuali.

Parametri

• scriptIndex - Obbligatorio ScriptIndex - indice di lancio attuale: 0 significa il primo, poi 1, 2... Passalo GetScriptsList; non è serial, il nome del file, e non il risultato di StartScript. Un indice negativo/mancante non cambia nulla.

Valore restituito

void - nessun valore restituito. Non confrontare la chiamata con true/1. Verificare lo stato leggendo separatamente GetScriptState; il risultato di tale lettura è 0 (nessuna partenza), 1 (corsa), 2 (pausa).

Comportamento

• Funziona solo con le esecuzioni della sessione corrente. Una scheda aperta senza esecuzione non è un avvio attivo. L'arresto non elimina il file originale né interrompe la connessione al server.
• Gli indici sono dinamici: le posizioni possono spostarsi dopo il completamento di un'altra corsa. Più chiamate API non sono un'operazione atomica. Gli esempi sono progettati per l'assenza di modifiche parallele all'elenco; cercare nuovamente il lancio desiderato prima dell'azione e non memorizzare l'indice tramite UO.Wait.
• Si tratta di un'opzione, non di un comando "continua sempre". Le pause manuali e automatiche sono indipendenti: il passaggio a manuale non rimuove la pausa di interruzione della connessione. Il codice 2 non spiega il motivo della pausa. Se interrompi il tuo lancio in questo modo, non sarà possibile effettuare la chiamata successiva per continuarlo; riprendere da IDE/manager o altro script.

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.

for (int index = 0; index < UO.GetScriptsCount(); index++)
    if (UO.GetScriptName(index) == "Worker")
    { UO.PauseResumeScript(index); break; }

1. Attiva/disattiva pausa per nome - script diretto

Parametri e flusso di esecuzione:

• MineOre è un esempio del nome visualizzato di una procedura già in esecuzione. FindNamedRun restituisce il primo indice corrispondente o -1. Chiamata da altro controllore; richiamando di nuovo si ripristina la pausa manuale.
• Gli indici sono dinamici: le posizioni possono spostarsi dopo il completamento di un'altra corsa. Più chiamate API non sono un'operazione atomica. Gli esempi sono progettati per l'assenza di modifiche parallele all'elenco; cercare nuovamente il lancio desiderato prima dell'azione e non memorizzare l'indice tramite UO.Wait.

var index = FindNamedRun("MineOre");
if (Truth(index >= 0))
{
    UO.PauseResumeScript(index);
}

dynamic FindNamedRun(dynamic wanted)
{
    var indices = UO.GetScriptsList();
    foreach (var index in indices)
    {
        if (Truth(UO.GetScriptName(index) == wanted))
        {
            return index;
        }
    }
    return -1;
}

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

2. Mettere in pausa un avvio in esecuzione - funzione script

Parametri e flusso di esecuzione:

• Il segno di spunta == 1 limita l'azione a un trigger in esecuzione. Il valore 2 non viene utilizzato come indicazione di "cancellazione pausa manuale" perché potrebbe indicare assenza di comunicazione.
• Gli indici sono dinamici: le posizioni possono spostarsi dopo il completamento di un'altra corsa. Più chiamate API non sono un'operazione atomica. Gli esempi sono progettati per l'assenza di modifiche parallele all'elenco; cercare nuovamente il lancio desiderato prima dell'azione e non memorizzare l'indice tramite UO.Wait.

return  RunScenario();
 object? RunScenario()
{
    var index = FindNamedRun("MineOre");
    if (Truth(index >= 0))
    {
        if (Truth(UO.GetScriptState(index) == 1))
        {
            UO.PauseResumeScript(index);
        }
    }

    return null;
}

dynamic FindNamedRun(dynamic wanted)
{
    var indices = UO.GetScriptsList();
    foreach (var index in indices)
    {
        if (Truth(UO.GetScriptName(index) == wanted))
        {
            return index;
        }
    }

    return -1;
}

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

3. Seleziona esegui per file - classe di script

Parametri e flusso di esecuzione:

• Sostituisci il percorso assoluto con il tuo. FindFileRun confronta i percorsi senza distinzione tra maiuscole e minuscole e restituisce la prima esecuzione di questo file; È possibile eseguire diverse procedure in un unico file.
• Gli indici sono dinamici: le posizioni possono spostarsi dopo il completamento di un'altra corsa. Più chiamate API non sono un'operazione atomica. Gli esempi sono progettati per l'assenza di modifiche parallele all'elenco; cercare nuovamente il lancio desiderato prima dell'azione e non memorizzare l'indice tramite UO.Wait.

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 wantedPath = "D:/Game/AutoLoad/Scripts/Worker.csx";
        var index = FindFileRun(wantedPath);
        if (Truth(index >= 0))
        {
            UO.PauseResumeScript(index);
        }

        return null;
    }

    dynamic FindFileRun(dynamic wantedPath)
    {
        var indices = UO.GetScriptsList();
        foreach (var index in indices)
        {
            if (Truth(Convert.ToString(ReplaceText(UO.GetScriptPath(index), Chr(92), "/")) == Convert.ToString(ReplaceText(wantedPath, Chr(92), "/"))))
            {
                return index;
            }
        }

        return -1;
    }

    string Chr(object? value) => ((char)Convert.ToInt32(value)).ToString();
    bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
    string ReplaceText(object? value, object? oldValue, object? newValue) => (Convert.ToString(value) ?? "").Replace(Convert.ToString(oldValue) ?? "", Convert.ToString(newValue) ?? "");
}

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.PauseResumeScript(scriptIndex) — UO.PauseResumeScript(Any)

Parametri: scriptIndex (Any)

Risultato: void / Unit.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "pauseresumescript": bridge.PauseResumeScript(Arg(0)); return InjectionValue.Unit;

---

UO.SetEvent

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

Firme C#

void UO.SetEvent(object? name, object? stateValue);
void UO.SetEvent(object? name, object? stateValue, object? repeatOrHandler);
void UO.SetEvent(object? nameValue, object? stateValue, object? repeatValue, object? subNameValue);

Abilita o disabilita il monitoraggio dei cambiamenti nello stato del personaggio e ti consente di selezionare una reazione una tantum o ripetuta. Ad esempio, puoi annullare il bersaglio rimanente una volta dopo la morte o ricevere avvisi sulla resistenza bassa. Il gestore è specificato separatamente dalla condizione; lo script principale dovrebbe continuare ad essere eseguito UO.Wait.

Parametri

• name — Una stringa con uno dei cinque nomi: ChangeHitPoints, ChangeMana, ChangeStamina, Morte, SeeNewPlayer. Il caso non è importante; è accettabile il prefisso ev, ad esempio evChangeMana. Lo spazio bianco attorno ai bordi viene rimosso. Non esiste un catalogo numerico degli eventi; un nome arbitrario non crea un nuovo evento.
• nameValue - Stesso nome dell'evento del nome; questo è il nome del primo parametro in una forma a quattro argomenti, non un valore facoltativo.
• stateValue - true/1 attiva la sorveglianza, false/0 annulla l'iscrizione. Passa valori booleani senza virgolette. In una conversione numerica, qualsiasi numero intero diverso da zero include un'osservazione. La disabilitazione non attende né arresta un gestore già in esecuzione.
• repeatOrHandler — Il terzo argomento ha due scopi. Una stringa non numerica e non vuota, come "OnManaChanged", specifica un gestore di ripetizione automatica. Numero/bool imposta solo la ripetizione: false/0 — un'operazione, true/1 — ripetizione; nessun gestore è assegnato in questo modulo. Anche la stringa "1" è numerica e non è un nome di procedura. Per un gestore occasionale, utilizzare quattro argomenti.
• repeatValue - Nel modulo con quattro argomenti: false/0 - elimina l'abbonamento dopo la prima transizione rilevata, true/1 - lascialo per le modifiche successive. Un abbonamento una tantum viene annullato anche quando il gestore non viene trovato o il gestore ne rifiuta il lancio; Non confondere il rilevamento di un evento con il completamento con successo di una procedura.

Valore restituito

void - nessun valore. Chiamata su una linea separata, senza risultato var = e senza confronto con true/1. Il completamento della registrazione non conferma che il gestore è stato trovato, avviato o che il server ha eseguito un'azione. Se il nome della procedura non viene trovato nell'evento, la chiamata non avviene.

Comportamento

• Due argomenti: false disabilita l'evento; true prevede l'osservazione ripetuta senza conduttore. Qualsiasi procedura con un nome corrispondente non viene sostituita automaticamente. Questo modulo non restituisce alcun risultato e non sostituisce il test HP/Mana/Dead.
• I quattro argomenti specificano esplicitamente il nome dell'evento, l'abilitazione, la ripetizione e il gestore. Entrambi i parametri booleani sono scritti senza virgolette. false/0 = one-shot: l'abbonamento viene annullato dopo la prima transizione rilevata, non dopo la fine del gestore.
• La nuova registrazione di un evento sostituisce le sue impostazioni precedenti e ricorda lo stato corrente come nuovo punto di riferimento. Le sottoscrizioni SetEvent e SetEventProc a un nome normalizzato all'interno di uno script utilizzano un record e non si accumulano.
• ChangeHitPoints confronta l'attuale HP self con l'istantanea precedente; si attiva sia quando si perde che quando si ripristina la salute. ChangeMana e ChangeStamina reagiscono in modo simile in entrambe le direzioni. Non si tratta solo di danni, consumo di mana o fatica.
• La morte viene innescata quando si passa da vivo a morto. La registrazione di un personaggio già morto non chiama immediatamente il gestore; morire di nuovo dopo la resurrezione può innescarlo nuovamente.
• SeeNewPlayer confronta l'insieme dei cellulari scaricati escludendo 0 e self. Il nome non significa testare il giocatore reale: questo include NPC e le creature. Uno o più nuovi serial per controllo provocano un tentativo di avvio. Anche il ritorno del defunto mobile dal set caricato può essere considerato una nuova apparizione. ID non viene passato al gestore: gli oggetti necessari devono essere trovati separatamente.
• UO.Wait e WaitAsync dividono l'attesa in intervalli fino a 25 ms e controllano gli eventi dopo ciascuno; Anche UO.Wait(0) esegue il controllo. Si tratta di interrogare lo stato disponibile anziché intercettare ogni pacchetto di rete: i cambiamenti rapidi e i ritorni tra i controlli potrebbero essere persi. Non esiste un monitoraggio costante in un ciclo di calcolo senza UO.Wait o dopo il completamento dello script principale.
• Il nome del gestore è pre-associato al delegato C# tramite RegisterRoutine. La richiamata viene eseguita in modo asincrono in questa sessione; un compito non si sovrappone a se stesso. Dopo la fine della sceneggiatura principale, le sue ulteriori azioni sono vietate.
• Una sottoscrizione si riferisce a un'istanza di uno script in esecuzione. Rimuovilo in Main, che lo ha creato: il comando con lo stesso nome all'interno di un gestore lanciato separatamente cambierà le proprie sottoscrizioni. L'annullamento della registrazione non interrompe un gestore già in esecuzione. Utilizzare try/finally per l'uscita normale o un errore gestibile; l'arresto forzato interrompe anche l'ulteriore polling di questo script.
• Un nome evento sconosciuto e non vuoto viene rifiutato con un messaggio di sistema al momento della registrazione. Un nome vuoto non fa nulla. La presenza di un handler viene verificata solo quando attivato; È meglio rilevare in anticipo un errore nel suo nome tramite SubExists e controllare lo script in IDE.

In C# l'handler deve essere registrato esplicitamente: RegisterRoutine("Handler", Handler). Le modifiche a HP, mana e resistenza arrivano attraverso la coda degli eventi nativi; La morte e SeeNewPlayer vengono confrontati con le istantanee del mondo locale. Le sottoscrizioni dirette con argomenti sono disponibili tramite SubscribeEvent("UO.JournalEntry", gestore) e nomi nativi simili. Tutti gli abbonamenti vengono rilasciati quando questa esecuzione viene completata o annullata.

File C# caricati

Oltre ai delegati locali, l'attuale gestore supporta voci C# caricate esplicitamente con una chiave come Child.csx::Main. SubExists e FunRunning accettano tale chiave; CallSub esegue il file senza Args e Exec("exec Child.csx::Main 'north gate' 42") passa Args. La chiave con spazi è racchiusa tra virgolette all'interno di Exec. È accettabile un nome breve univoco, un nome ambiguo non seleziona un file casuale. La registrazione locale ha la precedenza. Il lancio di un file ottiene il proprio contesto e la propria durata nel mondo/manager attuale; i delegati locali appartengono all'esecuzione che li ha registrati.

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.

RegisterRoutine("HealthChanged", () => UO.Print("HP changed"));
UO.SetEvent("ChangeHitPoints", true, false, "HealthChanged");
await WaitAsync(5000);

1. Annulla un bersaglio incompleto una volta dopo la morte - script diretto

Parametri e flusso di esecuzione:

• L'osservazione dura otto secondi. La morte di un personaggio già morto non chiama immediatamente il conduttore. Il secondo evento di morte dopo la resurrezione non viene più elaborato in questo esempio.
• Il gestore controlla il cursore attivo del target al momento dell'esecuzione e solo allora chiama CancelTarget. In questo esempio una coda preparata senza cursore attivo non viene annullata. La sceneggiatura non resuscita il personaggio, non interrompe tutte le sceneggiature e non termina Main. Non eseguire l'esempio se desideri mantenere attivo il target.

var registrationOnFirstDeath = RegisterRoutine("OnFirstDeath", OnFirstDeath);
UO.SetEvent("Death", true, false, "OnFirstDeath");
try
{
    UO.Wait(8000);
}
finally
{
    UO.SetEvent("Death", false);
}

void OnFirstDeath()
{
    if (Truth(UO.Targeting()))
    {
        UO.CancelTarget();
        UO.Print("Death detected: active targeting cancelled");
    }
    else
    {
        UO.Print("Death detected: no active target");
    }
}

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

2. Avvertenza sulla resistenza ripetuta: forma breve - funzione script

Parametri e flusso di esecuzione:

• 24 × 250 ms – sei secondi. 10 è la nostra soglia nel gestore, non l'argomento aggiuntivo SetEvent. Anche l'aumento della resistenza è causato dal conduttore, ma con un valore da 10 il messaggio non viene visualizzato.
• true, "OnFatigue" è diverso da true, true: quest'ultima opzione specifica la ripetizione senza procedura. Lo script non aumenta la resistenza né modifica la velocità del server.

return  RunScenario();
 object? RunScenario()
{
    var registrationOnFatigue = RegisterRoutine("OnFatigue", OnFatigue);
    UO.SetEvent("evChangeStamina", true, "OnFatigue");
    try
    {
        for (int tick = (int)(1); tick <= 24; tick += (int)(1))
        {
            UO.Wait(250);
        }
    }
    finally
    {
        UO.SetEvent("ChangeStamina", false);
    }

    return null;
}

void OnFatigue()
{
    var staminaNow = UO.Stamina();
    if (Truth(staminaNow < 10))
    {
        UO.Print("Stamina is " + Convert.ToString(staminaNow) + ": consider resting");
    }
}

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

3. Attiva/disattiva il gestore del mana senza accumulare abbonamenti - classe di script

Parametri e flusso di esecuzione:

• Per i primi due secondi, ogni modifica rilevata attiva OnManaLog. Per i successivi tre secondi viene utilizzato OnLowMana. La registrazione di un secondo gestore non lo attiva di per sé.
• La sostituzione non interrompe la vecchia procedura già in esecuzione. Questi gestori brevi non utilizzano le variabili locali principali. Se l'imposizione di procedure è vietata, il manager può rifiutare il lancio: per questa modalità, controlla Mana direttamente in Main.

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 registrationOnManaLog = RegisterRoutine("OnManaLog", OnManaLog);
        var registrationOnLowMana = RegisterRoutine("OnLowMana", OnLowMana);
        UO.SetEvent("ChangeMana", true, true, "OnManaLog");
        try
        {
            UO.Wait(2000);
            UO.SetEvent("ChangeMana", true, true, "OnLowMana");
            UO.Wait(3000);
        }
        finally
        {
            UO.SetEvent("ChangeMana", false);
        }

        return null;
    }

    void OnManaLog()
    {
        UO.Print("Mana now: " + Convert.ToString(UO.Mana()));
    }

    void OnLowMana()
    {
        if (Truth(UO.Mana() < 20))
        {
            UO.Print("Mana below 20: check the cost before casting");
        }
    }

    bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
    private IDisposable RegisterRoutine(string name, Action handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Action<string[]> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<string[], Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
}

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

Parametri: name (Any), stateValue (Any)

Risultato: void / Unit.

Durante la chiamata:

• ClassicUO.CSharp.CSharpCallbacks.TryInvoke.
• InjectionScript.Runtime.InjectionApiUO.SetEvent.
• InjectionScript.Runtime.InjectionApiUO.SetEvent: SetEvent(name, stateValue, InjectionValue.True, new InjectionValue(string.Empty)).

Codice interno di implementazione; non è uno script autonomo.

case "SetEvent": SetStateEvent(arguments); return true;

Codice interno di implementazione; non è uno script autonomo.

public void SetEvent(InjectionValue name, InjectionValue stateValue)

            => SetEvent(name, stateValue, InjectionValue.True, new InjectionValue(string.Empty));

UO.SetEvent(name, stateValue, repeatOrHandler) — UO.SetEvent(Any,Any,Any)

Parametri: name (Any), stateValue (Any), repeatOrHandler (Any)

Risultato: void / Unit.

Durante la chiamata:

• ClassicUO.CSharp.CSharpCallbacks.TryInvoke.
• InjectionScript.Runtime.InjectionApiUO.SetEvent.
• InjectionScript.Runtime.InjectionValue.ToString: repeatOrHandler.ToString().
• InjectionScript.Runtime.NumberConversions.TryStr2Int: NumberConversions.TryStr2Int(raw, out _).
• InjectionScript.Runtime.InjectionApiUO.SetEvent: SetEvent(name, stateValue, InjectionValue.True, repeatOrHandler).

Codice interno di implementazione; non è uno script autonomo.

case "SetEvent": SetStateEvent(arguments); return true;

Codice interno di implementazione; non è uno script autonomo.

public void SetEvent(InjectionValue name, InjectionValue stateValue, InjectionValue repeatOrHandler)

        {

            string raw = repeatOrHandler.ToString() ?? string.Empty;

            if (!string.IsNullOrWhiteSpace(raw) && !NumberConversions.TryStr2Int(raw, out _))

                SetEvent(name, stateValue, InjectionValue.True, repeatOrHandler);

            else

                SetEvent(name, stateValue, repeatOrHandler, new InjectionValue(string.Empty));

        }

UO.SetEvent(nameValue, stateValue, repeatValue, subNameValue) — UO.SetEvent(Any,Any,Any,Any)

Parametri: nameValue (Any), stateValue (Any), repeatValue (Any), subNameValue (Any)

Risultato: void / Unit.

Durante la chiamata:

• ClassicUO.CSharp.CSharpCallbacks.TryInvoke.
• InjectionScript.Runtime.InjectionApiUO.SetEvent.
• InjectionScript.Runtime.InjectionApiUO.NormalizeLegacyEventName: NormalizeLegacyEventName(nameValue.ToString()).
• InjectionScript.Runtime.InjectionValue.ToString: nameValue.ToString().
• InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(stateValue).
• InjectionScript.Runtime.InjectionApiUO.IsSupportedLegacyEventName: IsSupportedLegacyEventName(name).
• InjectionScript.Runtime.InjectionApiUO.SystemMessage: SystemMessage($"SetEvent: unsupported event '{name}'. Supported: SeeNewPlayer, Death, ChangeHitPoints, ChangeMana, ChangeStamina.").
• InjectionScript.Runtime.InjectionApiUO.NormalizeLegacyEventHandler: NormalizeLegacyEventHandler(subNameValue.ToString()).
• InjectionScript.Runtime.InjectionApiUO.CaptureLegacyEventSnapshot: CaptureLegacyEventSnapshot(subscription).

Codice interno di implementazione; non è uno script autonomo.

case "SetEvent": SetStateEvent(arguments); return true;

Codice interno di implementazione; non è uno script autonomo.

public void SetEvent(InjectionValue nameValue, InjectionValue stateValue, InjectionValue repeatValue, InjectionValue subNameValue)

        {

            string name = NormalizeLegacyEventName(nameValue.ToString());

            if (string.IsNullOrEmpty(name))

                return;



            bool enabled = NumberConversions.ToInt(stateValue) != 0;

            eventStates[name] = enabled ? 1 : 0;

            if (!enabled)

            {

                legacyEvents.Remove(name);

                return;

            }



            if (!IsSupportedLegacyEventName(name))

            {

                eventStates[name] = 0;

                legacyEvents.Remove(name);

                SystemMessage($"SetEvent: unsupported event '{name}'. Supported: SeeNewPlayer, Death, ChangeHitPoints, ChangeMana, ChangeStamina.");

                return;

            }



            var subscription = new LegacyEventSubscription

            {

                Name = name,

                Repeat = NumberConversions.ToInt(repeatValue) != 0,

                Handler = NormalizeLegacyEventHandler(subNameValue.ToString())

            };

            CaptureLegacyEventSnapshot(subscription);

            legacyEvents[name] = subscription;

        }

---

UO.SetEventProc

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

Firme C#

void UO.SetEventProc(object? eventname, object? procname);

Designa una procedura che il client eseguirà quando uno stato osservato cambia: ad esempio, quando si perde la salute, il mana cambia o appare un nuovo mobile. Permette di separare la reazione dal ciclo principale. La registrazione in sé non esegue nulla: lo script principale deve rimanere attivo; I punti di controllo C#, WaitAsync e UO.Wait gestiscono gli eventi.

Parametri

• eventname — Una stringa con uno dei cinque nomi: ChangeHitPoints, ChangeMana, ChangeStamina, Morte, SeeNewPlayer. Il caso non è importante; è accettabile il prefisso ev, ad esempio evChangeMana. Lo spazio bianco attorno ai bordi viene rimosso. Non esiste un catalogo numerico degli eventi; un nome arbitrario non crea un nuovo evento.

Valore restituito

void - nessun valore. Chiamata su una linea separata, senza risultato var = e senza confronto con true/1. Il completamento della registrazione non conferma che il gestore è stato trovato, avviato o che il server ha eseguito un'azione. Se il nome della procedura non viene trovato nell'evento, la chiamata non avviene.

Comportamento

• Entrambi gli argomenti sono obbligatori. L'abbonamento è ricorrente: le nuove modifiche rilevate causano nuovi tentativi di avvio. In uno script in esecuzione, un gestore viene assegnato a un nome di evento normalizzato; la nuova registrazione lo sostituisce e aggiorna lo snapshot iniziale. SetEventProc(event, "") annulla l'iscrizione nello stesso script. Per una reazione una tantum, usa SetEvent(event, true, false, "Handler").
• ChangeHitPoints confronta l'attuale HP self con l'istantanea precedente; si attiva sia quando si perde che quando si ripristina la salute. ChangeMana e ChangeStamina reagiscono in modo simile in entrambe le direzioni. Non si tratta solo di danni, consumo di mana o fatica.
• La morte viene innescata quando si passa da vivo a morto. La registrazione di un personaggio già morto non chiama immediatamente il gestore; morire di nuovo dopo la resurrezione può innescarlo nuovamente.
• SeeNewPlayer confronta l'insieme dei cellulari scaricati escludendo 0 e self. Il nome non significa testare il giocatore reale: questo include NPC e le creature. Uno o più nuovi serial per controllo provocano un tentativo di avvio. Anche il ritorno del defunto mobile dal set caricato può essere considerato una nuova apparizione. ID non viene passato al gestore: gli oggetti necessari devono essere trovati separatamente.
• UO.Wait e WaitAsync dividono l'attesa in intervalli fino a 25 ms e controllano gli eventi dopo ciascuno; Anche UO.Wait(0) esegue il controllo. Si tratta di interrogare lo stato disponibile anziché intercettare ogni pacchetto di rete: i cambiamenti rapidi e i ritorni tra i controlli potrebbero essere persi. Non esiste un monitoraggio costante in un ciclo di calcolo senza UO.Wait o dopo il completamento dello script principale.
• Il nome del gestore è pre-associato al delegato C# tramite RegisterRoutine. La richiamata viene eseguita in modo asincrono in questa sessione; un compito non si sovrappone a se stesso. Dopo la fine della sceneggiatura principale, le sue ulteriori azioni sono vietate.
• Una sottoscrizione si riferisce a un'istanza di uno script in esecuzione. Rimuovilo in Main, che lo ha creato: il comando con lo stesso nome all'interno di un gestore lanciato separatamente cambierà le proprie sottoscrizioni. L'annullamento della registrazione non interrompe un gestore già in esecuzione. Utilizzare try/finally per l'uscita normale o un errore gestibile; l'arresto forzato interrompe anche l'ulteriore polling di questo script.
• Un nome evento sconosciuto e non vuoto viene rifiutato con un messaggio di sistema al momento della registrazione. Un nome vuoto non fa nulla. La presenza di un handler viene verificata solo quando attivato; È meglio rilevare in anticipo un errore nel suo nome tramite SubExists e controllare lo script in IDE.

In C# l'handler deve essere registrato esplicitamente: RegisterRoutine("Handler", Handler). Le modifiche a HP, mana e resistenza arrivano attraverso la coda degli eventi nativi; La morte e SeeNewPlayer vengono confrontati con le istantanee del mondo locale. Le sottoscrizioni dirette con argomenti sono disponibili tramite SubscribeEvent("UO.JournalEntry", gestore) e nomi nativi simili. Tutti gli abbonamenti vengono rilasciati quando questa esecuzione viene completata o annullata.

File C# caricati

Oltre ai delegati locali, l'attuale gestore supporta voci C# caricate esplicitamente con una chiave come Child.csx::Main. SubExists e FunRunning accettano tale chiave; CallSub esegue il file senza Args e Exec("exec Child.csx::Main 'north gate' 42") passa Args. La chiave con spazi è racchiusa tra virgolette all'interno di Exec. È accettabile un nome breve univoco, un nome ambiguo non seleziona un file casuale. La registrazione locale ha la precedenza. Il lancio di un file ottiene il proprio contesto e la propria durata nel mondo/manager attuale; i delegati locali appartengono all'esecuzione che li ha registrati.

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.

RegisterRoutine("HealthChanged", () => UO.Print("HP changed"));
UO.SetEventProc("ChangeHitPoints", "HealthChanged");
await WaitAsync(5000);

1. Monitora i cambiamenti di integrità per 10 secondi - script diretto

Parametri e flusso di esecuzione:

• ChangeHitPoints osserva HP del suo personaggio. OnHealthChanged - nome del metodo sotto/sopra Main nello stesso file caricato. UO.Wait gestisce gli eventi; un secondo argomento vuoto disabilita la ripetizione.
• Il conduttore si limita ad avvisare e non seleziona automaticamente il trattamento. Quando si cambia HP 60 → 50 → 70 vengono eseguite due reazioni; Questo non è un contatore di visite.

var registrationOnHealthChanged = RegisterRoutine("OnHealthChanged", OnHealthChanged);
UO.SetEventProc("ChangeHitPoints", "OnHealthChanged");
try
{
    for (int tick = (int)(1); tick <= 40; tick += (int)(1))
    {
        UO.Wait(250);
    }
}
finally
{
    UO.SetEventProc("ChangeHitPoints", "");
}

void OnHealthChanged()
{
    var hp = UO.HP();
    if (Truth(hp < 40))
    {
        UO.Print("Low health: " + Convert.ToString(hp) + ". Check healing or retreat.");
    }
    else
    {
        UO.Print("Health changed: " + Convert.ToString(hp));
    }
}

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

2. Il monitoraggio del mana e della resistenza durante la preparazione è una funzione dello script

Parametri e flusso di esecuzione:

• evChangeMana e ChangeMana sono un evento. Esistono due abbonamenti indipendenti e due gestori diversi, non due gestori con lo stesso nome. Le soglie 20 e 10 possono essere modificate.
• L'attesa dura 5 secondi. Viene rilevato anche il ripristino delle risorse, ma non emette un avviso quando il valore è già superiore alla soglia.

return  RunScenario();
 object? RunScenario()
{
    var registrationOnManaChanged = RegisterRoutine("OnManaChanged", OnManaChanged);
    var registrationOnStaminaChanged = RegisterRoutine("OnStaminaChanged", OnStaminaChanged);
    UO.SetEventProc("evChangeMana", "OnManaChanged");
    UO.SetEventProc("ChangeStamina", "OnStaminaChanged");
    try
    {
        for (int tick = (int)(1); tick <= 20; tick += (int)(1))
        {
            UO.Wait(250);
        }
    }
    finally
    {
        UO.SetEventProc("ChangeMana", "");
        UO.SetEventProc("ChangeStamina", "");
    }

    return null;
}

void OnManaChanged()
{
    if (Truth(UO.Mana() < 20))
    {
        UO.Print("Mana below 20: postpone expensive spells");
    }
}

void OnStaminaChanged()
{
    if (Truth(UO.Stamina() < 10))
    {
        UO.Print("Stamina below 10: consider a movement break");
    }
}

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

3. Nota i nuovi cellulari, quindi disabilita il monitoraggio - classe script

Parametri e flusso di esecuzione:

• SeeNewPlayer rileva la presenza di serial nell'insieme di cellulari caricato, incluso NPC. Caricare cinque creature contemporaneamente non garantisce cinque evocazioni.
• GetMobiles() - lettura separata del set effettivo, non ID dall'evento. Per selezionare un nemico sono necessarie condizioni esplicite; l'esempio non attacca intenzionalmente nessuno.

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 registrationOnMobileAppeared = RegisterRoutine("OnMobileAppeared", OnMobileAppeared);
        UO.SetEventProc("SeeNewPlayer", "OnMobileAppeared");
        try
        {
            UO.Wait(5000);
        }
        finally
        {
            UO.SetEventProc("SeeNewPlayer", "");
        }

        UO.Wait(1000);
        return null;
    }

    void OnMobileAppeared()
    {
        var mobiles = UO.GetMobiles();
        UO.Print("Loaded mobiles now: " + Convert.ToString(ArrayLength(mobiles)));
    }

    int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
    private IDisposable RegisterRoutine(string name, Action handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Action<string[]> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<string[], Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
}

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.SetEventProc(eventname, procname) — UO.SetEventProc(Any,Any)

Parametri: eventname (Any), procname (Any)

Risultato: void / Unit.

Durante la chiamata:

• ClassicUO.CSharp.CSharpCallbacks.TryInvoke.
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Text: Text(1).
• InjectionScript.Runtime.InjectionApiUO.SetEvent: SetEvent(arguments[0], InjectionValue.False).
• InjectionScript.Runtime.InjectionApiUO.SetEvent: SetEvent(arguments[0], InjectionValue.True, InjectionValue.True, arguments[1]).

Codice interno di implementazione; non è uno script autonomo.

case "SetEventProc":
                SetStateEvent([arguments[0], !string.IsNullOrWhiteSpace(Convert.ToString(arguments[1])), true, arguments[1]]);
                return true;

Codice interno di implementazione; non è uno script autonomo.

case "seteventproc":

                {

                    if (string.IsNullOrWhiteSpace(Text(1)))

                        SetEvent(arguments[0], InjectionValue.False);

                    else

                        SetEvent(arguments[0], InjectionValue.True, InjectionValue.True, arguments[1]);

                    return InjectionValue.Unit;

                }

---

UO.SetPauseScriptOnDisconnectStatus

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

Firme C#

void UO.SetPauseScriptOnDisconnectStatus(object? value);

Modifica la regola per la pausa degli script quando la connessione viene persa.

Parametri

• value - 0 si spegne; qualsiasi numero intero diverso da zero include.

Valore restituito

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

Comportamento

• SetPauseScriptOnDisconnectStatus imposta _manager.PauseScriptsOnDisconnect = abilitato != 0. Gli script già in esecuzione non ricevono il comando PauseResumeScript qui.
• Modifica l'impostazione del client. Il valore non è il risultato di un test di connessione e non conferma l'elaborazione da parte del server.

Script C# autonomi

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

Esempio semplice

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

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

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

1. Chiamata diretta - sceneggiatura diretta

Parametri e flusso di esecuzione:

• Modifica la regola per la pausa degli script quando la connessione viene persa.

UO.SetPauseScriptOnDisconnectStatus(1);

2. Opzione esplicita: funzione dello script

Parametri e flusso di esecuzione:

• SetPauseScriptOnDisconnectStatus imposta _manager.PauseScriptsOnDisconnect = abilitato != 0. Gli script già in esecuzione non ricevono il comando PauseResumeScript qui.

return  RunScenario();
 object? RunScenario()
{
    UO.SetPauseScriptOnDisconnectStatus(0);
    return null;
}

3. Funzione di supporto completa: classe di script

Parametri e flusso di esecuzione:

• Modifica l'impostazione del client. Il valore non è il risultato di un test di connessione e non conferma l'elaborazione da parte del server.

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

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

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

Implementazione del comando

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

UO.SetPauseScriptOnDisconnectStatus(value) — UO.SetPauseScriptOnDisconnectStatus(Any)

Parametri: value (Any)

Risultato: void / Unit.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "setpausescriptondisconnectstatus": bridge.SetPauseScriptOnDisconnectStatus(Arg(0)); return InjectionValue.Unit;

---

UO.SetScriptName

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

Firme C#

void UO.SetScriptName(object? scriptIndex, object? value);

Modifica il nome visualizzato di una corsa attiva. Aiuta a distinguere tra le attività in esecuzione nell'elenco e tramite GetScriptName.

Parametri

• scriptIndex - Obbligatorio ScriptIndex - indice di lancio attuale: 0 significa il primo, poi 1, 2... Passalo GetScriptsList; non è serial, il nome del file, e non il risultato di StartScript. Un indice negativo/mancante non cambia nulla.
• value - Valore richiesto: nuovo nome, convertito in una stringa. Gli spazi sono consentiti; è accettabile anche una stringa vuota. Questa è la firma dell'esecuzione corrente e non il nuovo nome del file o della procedura nell'origine.

Valore restituito

void - nessun valore restituito. Non confrontare la chiamata con true/1. Verificare lo stato leggendo separatamente GetScriptState; il risultato di tale lettura è 0 (nessuna partenza), 1 (corsa), 2 (pausa).

Comportamento

• Funziona solo con le esecuzioni della sessione corrente. Una scheda aperta senza esecuzione non è un avvio attivo. L'arresto non elimina il file originale né interrompe la connessione al server.
• Gli indici sono dinamici: le posizioni possono spostarsi dopo il completamento di un'altra corsa. Più chiamate API non sono un'operazione atomica. Gli esempi sono progettati per l'assenza di modifiche parallele all'elenco; cercare nuovamente il lancio desiderato prima dell'azione e non memorizzare l'indice tramite UO.Wait.

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.

for (int index = 0; index < UO.GetScriptsCount(); index++)
    if (UO.GetScriptName(index) == "Worker")
    { UO.SetScriptName(index, "Worker renamed"); break; }

1. Dai all'attività un nome chiaro: script diretto

Parametri e flusso di esecuzione:

• MineOre viene cercato nelle esecuzioni attive, Mining è la nuova firma. I nomi tra virgolette sono creati dall'utente e possono essere sostituiti.
• Gli indici sono dinamici: le posizioni possono spostarsi dopo il completamento di un'altra corsa. Più chiamate API non sono un'operazione atomica. Gli esempi sono progettati per l'assenza di modifiche parallele all'elenco; cercare nuovamente il lancio desiderato prima dell'azione e non memorizzare l'indice tramite UO.Wait.

var index = FindNamedRun("MineOre");
if (Truth(index >= 0))
{
    UO.SetScriptName(index, "Mining");
}

dynamic FindNamedRun(dynamic wanted)
{
    var indices = UO.GetScriptsList();
    foreach (var index in indices)
    {
        if (Truth(UO.GetScriptName(index) == wanted))
        {
            return index;
        }
    }
    return -1;
}

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

2. Distinguere tra attività di file diversi: funzione script

Parametri e flusso di esecuzione:

• Sostituisci wantedPath con il tuo percorso assoluto. La firma del primo avvio attivo di questo file cambia, ma il file su disco rimane nello stesso posto.
• Gli indici sono dinamici: le posizioni possono spostarsi dopo il completamento di un'altra corsa. Più chiamate API non sono un'operazione atomica. Gli esempi sono progettati per l'assenza di modifiche parallele all'elenco; cercare nuovamente il lancio desiderato prima dell'azione e non memorizzare l'indice tramite UO.Wait.

return  RunScenario();
 object? RunScenario()
{
    var wantedPath = "D:/Game/AutoLoad/Scripts/Worker.csx";
    var index = FindFileRun(wantedPath);
    if (Truth(index >= 0))
    {
        UO.SetScriptName(index, "Worker A");
    }

    return null;
}

dynamic FindFileRun(dynamic wantedPath)
{
    var indices = UO.GetScriptsList();
    foreach (var index in indices)
    {
        if (Truth(Convert.ToString(ReplaceText(UO.GetScriptPath(index), Chr(92), "/")) == Convert.ToString(ReplaceText(wantedPath, Chr(92), "/"))))
        {
            return index;
        }
    }

    return -1;
}

string Chr(object? value) => ((char)Convert.ToInt32(value)).ToString();
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
string ReplaceText(object? value, object? oldValue, object? newValue) => (Convert.ToString(value) ?? "").Replace(Convert.ToString(oldValue) ?? "", Convert.ToString(newValue) ?? "");

3. Aggiungi stato alla firma - Classe script

Parametri e flusso di esecuzione:

• GetScriptState = 2 aggiunge il testo in pausa al nome. Si tratta di una firma una tantum: non viene aggiornata automaticamente dopo aver continuato e non controlla la pausa stessa.
• Gli indici sono dinamici: le posizioni possono spostarsi dopo il completamento di un'altra corsa. Più chiamate API non sono un'operazione atomica. Gli esempi sono progettati per l'assenza di modifiche parallele all'elenco; cercare nuovamente il lancio desiderato prima dell'azione e non memorizzare l'indice tramite UO.Wait.

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 index = FindNamedRun("Mining");
        if (Truth(index >= 0))
        {
            var newName = "Mining";
            if (Truth(UO.GetScriptState(index) == 2))
            {
                newName = "Mining (paused)";
            }

            UO.SetScriptName(index, newName);
        }

        return null;
    }

    dynamic FindNamedRun(dynamic wanted)
    {
        var indices = UO.GetScriptsList();
        foreach (var index in indices)
        {
            if (Truth(UO.GetScriptName(index) == wanted))
            {
                return index;
            }
        }

        return -1;
    }

    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.SetScriptName(scriptIndex, value) — UO.SetScriptName(Any,Any)

Parametri: scriptIndex (Any), value (Any)

Risultato: void / Unit.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

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

---

UO.StartScript

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

Firme C#

int UO.StartScript(object? scriptPath);

Parametri

Valore restituito

int: numero di esecuzioni attive dall'esecuzione accettata; 65535 (0xFFFF) = errore di avvio. Questo non è l'indice del nuovo script, né è un bool, né il risultato del completamento.

Comportamento

• Vengono presi in considerazione i lanci in corso e quelli in pausa; sono esclusi quelli completati e che hanno ricevuto richiesta di cancellazione. Uno script in esecuzione solitamente tiene conto di se stesso. Il semplice caricamento della scheda IDE non è considerato un lancio.
• Gli indici sono le posizioni correnti nell'ordine di avvio. L'avvio/l'arresto degli script può spostare le posizioni. Chiamate diverse non formano un'istantanea atomica comune; rileggere l'elenco prima del successivo comando di controllo.
• GetScriptsList fornisce gli indici, GetScriptsCount la quantità, GetScriptState il codice dei tre stati. Non sostituire l'uno con l'altro né trattare qualsiasi risultato diverso da zero come il valore di true.

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.StartScript("Scripts/Worker.csx");
UO.Print("StartScript: " + Convert.ToString(result));

1. Prima chiamata e risultato: script diretto

Parametri e flusso di esecuzione:

• Esegui lo script C# fornito. Il numero 0, dove viene passato, denota l'indice; le parentesi vuote non significano argomenti. Il testo Print è solo un messaggio di esempio.
• Prima degli esempi, creare separatamente i file Worker.csx specificati. Un percorso non valido/inaccessibile, un Main inappropriato, un C# disabilitato o una corsa parallela disabilitata comporteranno un errore. Se la corsa precedente è ancora interrotta, è possibile un nuovo tentativo ritardato; accettare l'inizio non significa completamento. Un breve script potrebbe terminare prima di leggere la quantità restituita.
• int: numero di esecuzioni attive dall'esecuzione accettata; 65535 (0xFFFF) = errore di avvio. Questo non è l'indice del nuovo script, né è un bool, né il risultato del completamento.
• Obbligatorio ScriptPath è una stringa. Il percorso relativo inizia nella cartella AutoLoad di questo client; il percorso assoluto è accettabile. Racchiudere i percorsi con spazi tra virgolette. Hai bisogno di .csx con un codice di livello superiore o di un normale .cs/.csproj con un punto di ingresso supportato C#.

var count = UO.StartScript("Scripts/Worker.csx");
if (Truth(count==65535))
{
    UO.Print("launch failed");
}
else
{
    UO.Print("Active executions: " + Convert.ToString(count));
}

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

2. Utilizzare in un ciclo o in una condizione: funzione dello script

Parametri e flusso di esecuzione:

• This is a specific example of command sharing. Array indexing starts from zero; Please check the length before handling. UO.Wait(250), dove viene utilizzato, attende 250 millisecondi.
• Prima degli esempi, creare separatamente i file Worker.csx specificati. Un percorso non valido/inaccessibile, un Main inappropriato, un C# disabilitato o una corsa parallela disabilitata comporteranno un errore. Se la corsa precedente è ancora interrotta, è possibile un nuovo tentativo ritardato; accettare l'inizio non significa completamento. Un breve script potrebbe terminare prima di leggere la quantità restituita.
• int: numero di esecuzioni attive dall'esecuzione accettata; 65535 (0xFFFF) = errore di avvio. Questo non è l'indice del nuovo script, né è un bool, né il risultato del completamento.
• Obbligatorio ScriptPath è una stringa. Il percorso relativo inizia nella cartella AutoLoad di questo client; il percorso assoluto è accettabile. Racchiudere i percorsi con spazi tra virgolette. Hai bisogno di .csx con un codice di livello superiore o di un normale .cs/.csproj con un punto di ingresso supportato C#.

return  RunScenario();
 object? RunScenario()
{
    var count = UO.StartScript("Scripts/My Worker.csx");
    if (Truth(count != 65535))
    {
        var indices = UO.GetScriptsList();
        foreach (var index in indices)
        {
            UO.Print(Convert.ToString(index) + ": " + UO.GetScriptPath(index));
        }
    }

    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:

• Sotto Main c'è l'intera funzione. I suoi parametri e il risultato sono spiegati separatamente dal comando API che richiama.
• TryStartCSharp confronta il risultato con 65535 e restituisce true/false. Non attende il completamento e non trasforma la quantità in un indice.
• int: numero di esecuzioni attive dall'esecuzione accettata; 65535 (0xFFFF) = errore di avvio. Questo non è l'indice del nuovo script, né è un bool, né il risultato del completamento.
• Obbligatorio ScriptPath è una stringa. Il percorso relativo inizia nella cartella AutoLoad di questo client; il percorso assoluto è accettabile. Racchiudere i percorsi con spazi tra virgolette. Hai bisogno di .csx con un codice di livello superiore o di un normale .cs/.csproj con un punto di ingresso supportato C#.

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(TryStartCSharp("Scripts/Worker.csx")))
        {
            UO.Print("launch accepted");
        }
        else
        {
            UO.Print("check file, Main and execution settings");
        }

        return null;
    }

    dynamic TryStartCSharp(dynamic fileName)
    {
        var count = UO.StartScript(fileName);
        return Truth(count != 65535);
    }

    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.StartScript(scriptPath) — UO.StartScript(Any)

Parametri: scriptPath (Any)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "startscript": return new InjectionValue(bridge.StartScript(Text(0)));

---

UO.StopAllScripts

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

Firme C#

void UO.StopAllScripts();

Parametri

Non ci sono parametri.

Valore restituito

void - nessun valore restituito. Non confrontare la chiamata con true/1. Verificare lo stato leggendo separatamente GetScriptState; il risultato di tale lettura è 0 (nessuna partenza), 1 (corsa), 2 (pausa).

Comportamento

• Funziona solo con le esecuzioni della sessione corrente. Una scheda aperta senza esecuzione non è un avvio attivo. L'arresto non elimina il file originale né interrompe la connessione al server.
• Gli indici sono dinamici: le posizioni possono spostarsi dopo il completamento di un'altra corsa. Più chiamate API non sono un'operazione atomica. Gli esempi sono progettati per l'assenza di modifiche parallele all'elenco; cercare nuovamente il lancio desiderato prima dell'azione e non memorizzare l'indice tramite UO.Wait.
• Non ci sono argomenti. Le procedure in esecuzione e sospese, le query in sospeso e la coda di riesecuzione vengono annullate. Lo script chiamante riceve anche un annullamento: non inserire il salvataggio/report richiesto dopo questo comando. Gli altri profili e processi non sono interessati.

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

1. Arresto generale incondizionato - sceneggiatura diretta

Parametri e flusso di esecuzione:

• Il comando ha parentesi vuote. Esegui il salvataggio desiderato prima di chiamare. Anche il controller stesso verrà arrestato.
• Gli indici sono dinamici: le posizioni possono spostarsi dopo il completamento di un'altra corsa. Più chiamate API non sono un'operazione atomica. Gli esempi sono progettati per l'assenza di modifiche parallele all'elenco; cercare nuovamente il lancio desiderato prima dell'azione e non memorizzare l'indice tramite UO.Wait.

UO.StopAllScripts();

2. Fermati alla morte del personaggio - funzione dello script

Parametri e flusso di esecuzione:

• Connected controlla l'ingresso nel mondo, Dead controlla la morte. StopAllScripts viene chiamato solo quando entrambe le condizioni sono soddisfatte; l'esempio li controlla una volta.
• Gli indici sono dinamici: le posizioni possono spostarsi dopo il completamento di un'altra corsa. Più chiamate API non sono un'operazione atomica. Gli esempi sono progettati per l'assenza di modifiche parallele all'elenco; cercare nuovamente il lancio desiderato prima dell'azione e non memorizzare l'indice tramite UO.Wait.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Connected()))
    {
        if (Truth(UO.Dead()))
        {
            UO.StopAllScripts();
        }
    }

    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. Arresto generale dopo cinque secondi - lezione di script

Parametri e flusso di esecuzione:

• 5000 sono i millisecondi in UO.Wait, non il parametro StopAllScripts. La pausa manuale o automatica del controller può ritardare l'esecuzione; Questo non è un timer indipendente.
• Gli indici sono dinamici: le posizioni possono spostarsi dopo il completamento di un'altra corsa. Più chiamate API non sono un'operazione atomica. Gli esempi sono progettati per l'assenza di modifiche parallele all'elenco; cercare nuovamente il lancio desiderato prima dell'azione e non memorizzare l'indice tramite UO.Wait.

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 delayMs = 5000;
        UO.Wait(delayMs);
        UO.StopAllScripts();
        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.StopAllScripts() — UO.StopAllScripts()

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "stopallscripts": bridge.StopAllScripts(); return InjectionValue.Unit;

---

UO.StopScript

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

Firme C#

void UO.StopScript(object? scriptIndex);

Richiede l'annullamento di un lancio attivo, incluso uno in pausa. Utilizzare quando è necessario completare questa esecuzione anziché continuare in seguito.

Parametri

• scriptIndex - Obbligatorio ScriptIndex - indice di lancio attuale: 0 significa il primo, poi 1, 2... Passalo GetScriptsList; non è serial, il nome del file, e non il risultato di StartScript. Un indice negativo/mancante non cambia nulla.

Valore restituito

void - nessun valore restituito. Non confrontare la chiamata con true/1. Verificare lo stato leggendo separatamente GetScriptState; il risultato di tale lettura è 0 (nessuna partenza), 1 (corsa), 2 (pausa).

Comportamento

• Funziona solo con le esecuzioni della sessione corrente. Una scheda aperta senza esecuzione non è un avvio attivo. L'arresto non elimina il file originale né interrompe la connessione al server.
• Gli indici sono dinamici: le posizioni possono spostarsi dopo il completamento di un'altra corsa. Più chiamate API non sono un'operazione atomica. Gli esempi sono progettati per l'assenza di modifiche parallele all'elenco; cercare nuovamente il lancio desiderato prima dell'azione e non memorizzare l'indice tramite UO.Wait.
• La cancellazione è cooperativa: attende una pausa e viene controllata dal motore; Le azioni già inviate al server non vengono annullate. Un lancio annullato viene immediatamente rimosso dall'elenco attivo, sebbene il rilascio delle risorse possa comunque continuare. Non verificare il completamento rispetto all'indice precedente: potrebbe esserci già un'altra esecuzione sotto di esso.

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.

for (int index = 0; index < UO.GetScriptsCount(); index++)
    if (UO.GetScriptName(index) == "Worker")
    { UO.StopScript(index); break; }

1. Interrompi una procedura: script diretto

Parametri e flusso di esecuzione:

• MineOre: nome del lancio. -1 non viene trasferito a StopScript. Dopo l'arresto, l'indice salvato non viene più utilizzato.
• Gli indici sono dinamici: le posizioni possono spostarsi dopo il completamento di un'altra corsa. Più chiamate API non sono un'operazione atomica. Gli esempi sono progettati per l'assenza di modifiche parallele all'elenco; cercare nuovamente il lancio desiderato prima dell'azione e non memorizzare l'indice tramite UO.Wait.

var index = FindNamedRun("MineOre");
if (Truth(index >= 0))
{
    UO.StopScript(index);
}

dynamic FindNamedRun(dynamic wanted)
{
    var indices = UO.GetScriptsList();
    foreach (var index in indices)
    {
        if (Truth(UO.GetScriptName(index) == wanted))
        {
            return index;
        }
    }
    return -1;
}

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

2. Arresta un avvio in pausa - funzione script

Parametri e flusso di esecuzione:

• Il codice 2 seleziona una corsa in pausa. StopScript lo termina invece di riattivarlo; altri compiti continuano.
• Gli indici sono dinamici: le posizioni possono spostarsi dopo il completamento di un'altra corsa. Più chiamate API non sono un'operazione atomica. Gli esempi sono progettati per l'assenza di modifiche parallele all'elenco; cercare nuovamente il lancio desiderato prima dell'azione e non memorizzare l'indice tramite UO.Wait.

return  RunScenario();
 object? RunScenario()
{
    var index = FindNamedRun("MineOre");
    if (Truth(index >= 0))
    {
        if (Truth(UO.GetScriptState(index) == 2))
        {
            UO.StopScript(index);
        }
    }

    return null;
}

dynamic FindNamedRun(dynamic wanted)
{
    var indices = UO.GetScriptsList();
    foreach (var index in indices)
    {
        if (Truth(UO.GetScriptName(index) == wanted))
        {
            return index;
        }
    }

    return -1;
}

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

3. Interrompe l'esecuzione da un file specifico: classe di script

Parametri e flusso di esecuzione:

• Il percorso assoluto seleziona la prima esecuzione attiva del file. Ciò non significa eliminare un file o interrompere tutte le procedure da quel file.
• Gli indici sono dinamici: le posizioni possono spostarsi dopo il completamento di un'altra corsa. Più chiamate API non sono un'operazione atomica. Gli esempi sono progettati per l'assenza di modifiche parallele all'elenco; cercare nuovamente il lancio desiderato prima dell'azione e non memorizzare l'indice tramite UO.Wait.

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 wantedPath = "D:/Game/AutoLoad/Scripts/Worker.csx";
        var index = FindFileRun(wantedPath);
        if (Truth(index >= 0))
        {
            UO.StopScript(index);
        }

        return null;
    }

    dynamic FindFileRun(dynamic wantedPath)
    {
        var indices = UO.GetScriptsList();
        foreach (var index in indices)
        {
            if (Truth(Convert.ToString(ReplaceText(UO.GetScriptPath(index), Chr(92), "/")) == Convert.ToString(ReplaceText(wantedPath, Chr(92), "/"))))
            {
                return index;
            }
        }

        return -1;
    }

    string Chr(object? value) => ((char)Convert.ToInt32(value)).ToString();
    bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
    string ReplaceText(object? value, object? oldValue, object? newValue) => (Convert.ToString(value) ?? "").Replace(Convert.ToString(oldValue) ?? "", Convert.ToString(newValue) ?? "");
}

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.StopScript(scriptIndex) — UO.StopScript(Any)

Parametri: scriptIndex (Any)

Risultato: void / Unit.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "stopscript": bridge.StopScript(Arg(0)); return InjectionValue.Unit;

---

UO.SubExists

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

Firme C#

int UO.SubExists(object? subrutineName);

Controlla se il delegato C# con il nome specificato è registrato con l'esecuzione corrente. Si tratta di un registro delle funzioni di callback per una determinata sessione, senza ricercare automaticamente metodi arbitrari attraverso la riflessione; gli input di file caricati esplicitamente sono accessibili anche tramite chiave.

Parametri

• subrutineName è il nome della stringa dato da RegisterRoutine. Lo spazio bianco attorno ai bordi viene rimosso; Le ricerche di nomi registrati non fanno distinzione tra maiuscole e minuscole.

Valore restituito

int: 1 - la condizione è soddisfatta, 0 - non soddisfatta. Salva il risultato di una chiamata se sono necessari più controlli.

Comportamento

• La registrazione e le attività appartengono alla stessa esecuzione. Un altro personaggio, profilo o esecuzione successiva ha il proprio registro.
• RegisterRoutine accetta Action, Func<Task> o un delegato con un array di argomenti stringa su Exec. La rimozione della registrazione non esegue il codice e impedisce ulteriori ricerche del nome.
• Lo script principale deve rimanere attivo finché sono necessari i suoi aiutanti: una volta completato, le attività vengono cancellate e le registrazioni e gli abbonamenti vengono rilasciati.
• FunRunning non è un indice di gestione. GetScriptsList e GetScriptState descrivono lanci di file indipendenti; la richiamata locale non riceve un indice separato.
• L'errore di callback viene passato allo script principale al controllo successivo. I loop WaitAsync, UO.Wait e C# strumentati supportano la pausa, l'annullamento e l'elaborazione della coda degli eventi.

File C# caricati

Oltre ai delegati locali, l'attuale gestore supporta voci C# caricate esplicitamente con una chiave come Child.csx::Main. SubExists e FunRunning accettano tale chiave; CallSub esegue il file senza Args e Exec("exec Child.csx::Main 'north gate' 42") passa Args. La chiave con spazi è racchiusa tra virgolette all'interno di Exec. È accettabile un nome breve univoco, un nome ambiguo non seleziona un file casuale. La registrazione locale ha la precedenza. Il lancio di un file ottiene il proprio contesto e la propria durata nel mondo/manager attuale; i delegati locali appartengono all'esecuzione che li ha registrati.

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.

RegisterRoutine("Hello", () => UO.Print("Hello"));
UO.Print("Registered flag: " + UO.SubExists("Hello"));

1. Esegui la procedura opzionale disponibile: script diretto

Parametri e flusso di esecuzione:

• Il comando restituisce int: in C# controlla risultato != 0 o risultato == 1; il confronto diretto con true non è accettabile. La definizione di WeightWatch è fornita di seguito ed è registrata tramite RegisterRoutine prima che venga chiamato il comando.
• Salva l'esempio come file separato, caricalo in IDE/manager ed esegui Main in modo che il resto delle procedure finisca nella directory. WeightWatch/ManaWatch - procedure di addestramento completamente definite qui: tre misurazioni di peso/mana con un intervallo di UO.Wait(1000), cioè 1000 ms, emesse solo quando si entra nel mondo. Non si tratta di un monitoraggio continuo; una pausa può prolungare il tempo. Nell'esempio con due task deve essere consentito l'avvio simultaneo delle procedure.

var registrationWeightWatch = RegisterRoutine("WeightWatch", WeightWatch);
if (Truth(Truth(UO.SubExists("WeightWatch")) == true))
{
    UO.CallSub("WeightWatch");
}

while (UO.FunRunning("WeightWatch") != 0) await WaitAsync(25);

void WeightWatch()
{
    dynamic sample = 0;
    for (sample = (int)(1); sample <= 3; sample += (int)(1))
    {
        if (Truth(UO.Connected()))
        {
            UO.Print("Weight: " + Convert.ToString(UO.Weight()));
        }
        UO.Wait(1000);
    }
}

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

2. Seleziona il gestore di fallback - funzione script

Parametri e flusso di esecuzione:

• WeightWatch può essere caricato da un altro file. Se non è presente viene selezionato il ManaWatch qui dichiarato. Se il primario viene trovato ma non può essere avviato, non ci sarà alcuna transizione automatica al secondario.
• Salva l'esempio come file separato, caricalo in IDE/manager ed esegui Main in modo che il resto delle procedure finisca nella directory. WeightWatch/ManaWatch - procedure di addestramento completamente definite qui: tre misurazioni di peso/mana con un intervallo di UO.Wait(1000), cioè 1000 ms, emesse solo quando si entra nel mondo. Non si tratta di un monitoraggio continuo; una pausa può prolungare il tempo. Nell'esempio con due task deve essere consentito l'avvio simultaneo delle procedure.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var registrationManaWatch = RegisterRoutine("ManaWatch", ManaWatch);
    if (Truth(UO.SubExists("WeightWatch") == 1))
    {
        UO.CallSub("WeightWatch");
    }
    else if (Truth(UO.SubExists("ManaWatch")))
    {
        UO.CallSub("ManaWatch");
    }

    while (UO.FunRunning("ManaWatch") != 0)
        await WaitAsync(25);
    return null;
}

void ManaWatch()
{
    dynamic sample = 0;
    for (sample = (int)(1); sample <= 3; sample += (int)(1))
    {
        if (Truth(UO.Connected()))
        {
            UO.Print("Mana: " + Convert.ToString(UO.Mana()));
        }

        UO.Wait(1000);
    }
}

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

3. Controlla entrambe le definizioni prima di eseguire - classe script

Parametri e flusso di esecuzione:

• HaveMonitors verifica due nomi utilizzando &&. Se ne manca almeno uno, Main non richiama alcuna attività. Viene testato un insieme di definizioni, non una garanzia di successo dell'esecuzione simultanea.
• Salva l'esempio come file separato, caricalo in IDE/manager ed esegui Main in modo che il resto delle procedure finisca nella directory. WeightWatch/ManaWatch - procedure di addestramento completamente definite qui: tre misurazioni di peso/mana con un intervallo di UO.Wait(1000), cioè 1000 ms, emesse solo quando si entra nel mondo. Non si tratta di un monitoraggio continuo; una pausa può prolungare il tempo. Nell'esempio con due task deve essere consentito l'avvio simultaneo delle procedure.

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 registrationWeightWatch = RegisterRoutine("WeightWatch", WeightWatch);
        var registrationManaWatch = RegisterRoutine("ManaWatch", ManaWatch);
        if (Truth(HaveMonitors()))
        {
            UO.CallSub("WeightWatch");
            UO.CallSub("ManaWatch");
        }

        while (UO.FunRunning("WeightWatch") != 0 || UO.FunRunning("ManaWatch") != 0)
            await WaitAsync(25);
        return null;
    }

    dynamic HaveMonitors()
    {
        return UO.SubExists("WeightWatch") != 0 && UO.SubExists("ManaWatch") != 0;
    }

    void WeightWatch()
    {
        dynamic sample = 0;
        for (sample = (int)(1); sample <= 3; sample += (int)(1))
        {
            if (Truth(UO.Connected()))
            {
                UO.Print("Weight: " + Convert.ToString(UO.Weight()));
            }

            UO.Wait(1000);
        }
    }

    void ManaWatch()
    {
        dynamic sample = 0;
        for (sample = (int)(1); sample <= 3; sample += (int)(1))
        {
            if (Truth(UO.Connected()))
            {
                UO.Print("Mana: " + Convert.ToString(UO.Mana()));
            }

            UO.Wait(1000);
        }
    }

    bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
    private IDisposable RegisterRoutine(string name, Action handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Action<string[]> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<string[], Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
}

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.SubExists(subrutineName) — UO.SubExists(String)

Parametri: subrutineName (String)

Risultato: int / Integer.

Durante la chiamata:

• ClassicUO.CSharp.CSharpCallbacks.TryInvoke.
• InjectionScript.Runtime.InjectionApiUO.SubExists.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.SubExists: bridge.SubExists(subrutineName).

Codice interno di implementazione; non è uno script autonomo.

case "SubExists":
                string requested = Convert.ToString(arguments[0]) ?? "";
                result = Exists(requested) || events is ICSharpScriptHost known && known.HasCSharpScript(requested) ? 1 : 0;
                return true;

Codice interno di implementazione; non è uno script autonomo.

public int SubExists(string subrutineName) => bridge.SubExists(subrutineName) ? 1 : 0;

---

UO.Terminate

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

Firme C#

void UO.Terminate();
void UO.Terminate(object? subrutineName);

Parametri

• subrutineName — Stringa facoltativa. Nessun argomento o una stringa vuota seleziona l’ultimo file avviato; "all" richiede l’annullamento di tutte le esecuzioni. Per i file C# usa una chiave esatta del catalogo, ad esempio harvest.csx::Main. Un nome di callback locale come Harvest funziona solo dopo la registrazione esplicita con RegisterRoutine. Un file ha una sola entrata Main; i metodi della classe non diventano automaticamente procedure avviabili separatamente.

Valore restituito

void: il comando non restituisce un numero e non attende la terminazione del thread di lavoro. Richiede immediatamente la cancellazione. L'esecuzione si ferma al successivo controllo di annullamento; le pause, i punti di interruzione e le attese integrate vengono interrotte. Le azioni del server già inviate prima dell'annullamento non vengono annullate.

Comportamento

UO.FunRunning(name) == 0 può verificarsi anche subito dopo una richiesta di annullamento. Non significa che il callback precedente abbia terminato il blocco finally. Un altro CallSub o Exec con lo stesso nome locale viene ignorato finché il worker precedente non termina davvero.

• UO.Terminate() seleziona le procedure in base all'ordine di esecuzione anziché per nome, riga dell'editor, ora dell'ultima azione o ordine di visualizzazione. Anche una procedura in pausa è considerata in esecuzione.
• Il target locale appartenente a questa corsa viene cancellato e il restante percorso automatico viene annullato. La cancellazione del movimento viene eseguita sul thread del gioco; se il percorso è già stato sostituito da un altro percorso o utente, il precedente proprietario non lo interrompe. I passaggi inviati al server non vengono richiamati.
• Il comando rimane disponibile quando è abilitata l'impostazione per un avvio simultaneo. Una procedura annullata libera spazio solo dopo che il relativo thread di lavoro è stato cancellato; Prima di ciò, il nuovo lancio viene saltato.
• L'arresto per nome annulla anche i corrispondenti avvii in sospeso. Le procedure completate non vengono modificate. Il cliente segnala nello stato l'assenza di un lancio adeguato. Una chiamata bloccata a un plug-in nativo di terze parti che non supporta la cancellazione non può essere interrotta in modo sicuro interrompendo forzatamente il thread.

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.

Per i file C# usa una chiave esatta del catalogo, ad esempio harvest.csx::Main. Un nome di callback locale come Harvest funziona solo dopo la registrazione esplicita con RegisterRoutine. Un file ha una sola entrata Main; i metodi della classe non diventano automaticamente procedure avviabili separatamente.

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.

UO.Terminate("harvest.csx::Main");
UO.Print("Cancellation requested for harvest.csx::Main");

1. Smetti di raccogliere per nome, lasciando altre procedure: script diretto

Questo richiede l’annullamento di harvest.csx::Main già in esecuzione. Il messaggio non conferma né la fine del suo blocco finally né l’annullamento delle azioni di gioco già eseguite.

var procedureName = "harvest.csx::Main";
UO.Terminate(procedureName);
UO.Print("Cancellation requested for harvest.csx::Main");

2. Seleziona Principale solo da una funzione file-script specifica

La chiave esatta harvest.csx::Main è diversa da heal.csx::Main. Sostituiscila con quella del tuo file caricato. Suffissi arbitrari come #2 non creano un’altra entrata.

return  RunScenario();
 object? RunScenario()
{
    var procedureKey = "harvest.csx::Main";
    UO.Terminate(procedureKey);
    UO.Print("Cancellation requested: " + procedureKey);
    return null;
}

3. Modulo console compatibile tramite Exec - classe script

La stringa terminate harvest.csx::Main passa la stessa chiave tramite UO.Exec. Una chiave contenente spazi deve essere racchiusa tra virgolette nella stringa del comando.

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 command = "terminate harvest.csx::Main";
        UO.Exec(command);
        UO.Print("Stop command sent");
        return null;
    }
}

4. Interrompi l'ultima esecuzione quando l'integrità è bassa: script diretto

Parametri e flusso di esecuzione:

• Il modulo senza argomenti seleziona l'ultimo script in esecuzione, incluso quello in pausa. Questa è una politica di esempio, non una risposta obbligatoria alla cattiva salute; viene visualizzato un messaggio prima della richiesta di cancellazione.

if (UO.GetHP() <= 30)
{
    UO.Print("Low health: requesting cancellation of the most recent run");
    UO.Terminate();
}

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

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.Terminate.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Terminate: bridge.Terminate(string.Empty).

Codice interno di implementazione; non è uno script autonomo.

public void Terminate() => bridge.Terminate(string.Empty);

UO.Terminate(subrutineName) — UO.Terminate(String)

Parametri: subrutineName (String)

Risultato: void / Unit.

Durante la chiamata:

• ClassicUO.CSharp.CSharpCallbacks.TryInvoke.
• InjectionScript.Runtime.InjectionApiUO.Terminate.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Terminate: bridge.Terminate(subrutineName).

Codice interno di implementazione; non è uno script autonomo.

case "Terminate" when arguments.Length == 1:
                string routine = Convert.ToString(arguments[0]) ?? "";
                if (Exists(routine)) { Cancel(routine); return true; }
                if (Cancel(routine)) return true;
                return false;

Codice interno di implementazione; non è uno script autonomo.

public void Terminate(string subrutineName) => bridge.Terminate(subrutineName);

---

UO.TerminateAll

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

Firme C#

void UO.TerminateAll();

Parametri

Non ci sono parametri.

Valore restituito

void: nessun risultato. Il comando richiede l'annullamento di tutte le esecuzioni correnti e restituisce il controllo al codice chiamante se non è stato annullato. I thread di lavoro vengono ripuliti dopo l'attivazione dei controlli di annullamento.

Comportamento

• La sintassi esatta è UO.TerminateAll(), senza spazi all'interno del nome e senza argomenti. UO.Terminate("all") è supportato come notazione alternativa compatibile.
• Interrompe le procedure in esecuzione, le procedure sospese manualmente e con punti di interruzione, le attese integrate e le esecuzioni ritardate registrate. Richiamare quando non c'è lavoro è sicuro.
• La rimozione delle attrazioni locali e dei percorsi automatici tiene conto dei loro proprietari. Il percorso rimanente dello script interrotto viene annullato nel thread del gioco; il nuovo percorso dell'utente che lo ha sostituito viene salvato. I pacchetti motion già inviati non verranno annullati.
• Annulla non ripristina le azioni già inviate al server. Il codice del plug-in nativo di terze parti senza supporto per la cancellazione non può essere distrutto in modo sicuro insieme allo streaming. Sono consentiti nuovi avvii espliciti dopo l'esecuzione del comando; quando la casella è abilitata, aspettano che lo spazio si liberi, nel senso che il tentativo viene saltato anziché messo in coda fino al completamento della pulizia.

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

1. Impedisce a tutti gli script di controllare all'interno di uno script funzionante - script diretto

Parametri e flusso di esecuzione:

• TerminateAll non ha parametri. La condizione UO.Dead() verifica la morte del personaggio prima dell'iterazione successiva.
• Quando la condizione è soddisfatta, sia l'attuale esecuzione principale che quelle rimanenti C# vengono annullate. Il messaggio Print si trova prima dell'arresto perché dopo di esso il codice per questa procedura si interrompe.
• WaitAsync(250) specifica la pausa 250 millisecondi tra i controlli in questo esempio. Il comando stop non modifica la lunghezza delle normali pause dello script.

for (int cycle = (int)(1); cycle <= 10; cycle += (int)(1))
{
    if (Truth(UO.Dead()))
    {
        UO.Print("Character is dead: stopping all C# scripts");
        UO.TerminateAll();
    }
    await Delay(250);
}

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. Modulo compatibile con la funzione all-script

Parametri e flusso di esecuzione:

• Questa notazione alternativa utilizza UO.Terminate con un parametro subrutineName="all". Questo è l'equivalente di UO.TerminateAll().
• La stringa all è un valore speciale, non il nome della procedura che deve essere dichiarata. Anche EmergencyStop viene cancellato.
• Per la chiave di gioco di emergenza, utilizzare il comando a riga singola del primo esempio: la procedura separata EmergencyStop è essa stessa soggetta al divieto di esecuzioni parallele.

return  RunScenario();
 object? RunScenario()
{
    UO.Print("Stopping all C# scripts");
    UO.Terminate("all");
    return null;
}

3. Arresta il funzionamento generale se un oggetto richiesto diventa non disponibile - classe script

Parametri e flusso di esecuzione:

• GetSerial memorizza serial l'oggetto richiesto, qui il proprio zaino. Exists=0 significa che questo oggetto è attualmente sconosciuto al client.
• TerminateAll viene chiamato senza argomenti solo quando la condizione selezionata viene violata. Questa politica interrompe tutte le procedure, non solo il lavoro su un determinato zaino.
• Innanzitutto viene visualizzato il motivo dell'arresto. Una volta effettuata la richiesta di cancellazione, viene chiusa anche la procedura in corso; non si può contare sull'azione successiva.

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

     public object? RunScenario()
    {
        var bag = UO.GetSerial("backpack");
        if (Truth(UO.Exists(bag) == 0))
        {
            UO.Print("Required backpack is unavailable: stopping all scripts");
            UO.TerminateAll();
        }

        return null;
    }

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

4. Interrompi tutto il lavoro dopo aver perso la connessione: script diretto

Parametri e flusso di esecuzione:

• Se non c'è connessione, tutti gli avvii vengono interrotti. Il comando non restituisce il numero di script annullati e annulla anche l'esecuzione corrente.

if (UO.Connected() == 0)
{
    UO.Print("Disconnected: requesting cancellation of every active script");
    UO.TerminateAll();
}

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

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.TerminateAll.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Terminate: bridge.Terminate("all").

Codice interno di implementazione; non è uno script autonomo.

public void TerminateAll() => bridge.Terminate("all");

---

UO.Time

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

Firme C#

int UO.Time();

Legge l'ora locale del giorno del computer utilizzando il numero HHMMSS. Comodo per selezionare il tempo di funzionamento consentito, non per misurare la durata.

Parametri

Non ci sono parametri.

Valore restituito

int HHMMSS, 0..235959 con minuti e secondi validi. 07:29:35 -> 72935; mezzanotte -> 0. Zero è un tempo valido, non un errore o un flag logico false.

Comportamento

• Non ci sono parametri, né moduli con argomenti. Le parentesi vuote leggono solo l'ora: la chiamata non attende, non avvia un timer o non invia pacchetti al gioco.
• RealTimeSource.Ora si legge DateTime.Ora: la data/ora locale del computer, non UTC, non l'ora dello shard e non l'orologio del gioco. Il fuso orario, l'ora legale e il cambio manuale dell'orologio influiscono sui risultati. Ogni chiamata cattura un momento diverso.
• Gli zeri iniziali non vengono conservati, così come i millisecondi non vengono conservati. Numericamente, 13:00:00 meno 12:59:59 dà 4041, anche se è passato un secondo. A mezzanotte il valore torna a zero.
• Non sottrarre i codici del calendario per calcolare il ritardo. Usa Timer() e due segni di una corsa. L'orologio del calendario potrebbe tornare indietro.

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

1. Mostra campi temporali individuali - script diretto

Parametri e flusso di esecuzione:

• il timbro viene letto una volta per non mescolare secondi diversi. Int(timbro/10000) — ore; Int(timbro/100) MOD 100 — minuti; MOD 100 – secondi. Una stringa semplice non riempie i campi con zeri.

var stamp = UO.Time();
var hour = stamp / 10000;
var minute = stamp / 100 % 100;
var second = stamp % 100;
UO.Print(Convert.ToString(hour) + ":" + Convert.ToString(minute) + ":" + Convert.ToString(second));

2. Consenti serie solo nella fascia oraria serale - funzione script

Parametri e flusso di esecuzione:

• 180000 - 18:00:00 compreso; 220000 - 22:00:00 non compreso. Un controllo decide se continuare Main. Il palinsesto non è registrato e la serie non si avvia automaticamente.

return  RunScenario();
 object? RunScenario()
{
    var stamp = UO.Time();
    if (Truth(stamp >= 180000) && Truth(stamp < 220000))
    {
        UO.Print("Evening batch permitted by local schedule");
    }
    else
    {
        UO.Print("Outside the local schedule");
        return null;
    }

    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. Considera l'intervallo dopo la mezzanotte: lezione di scenario

Parametri e flusso di esecuzione:

• ClockInWindow(timbro,primo,ultimo) accetta HHMMSS valido. 230000..20000 significa da 23:00 compreso a 02:00 non compreso: OR tiene conto della mezzanotte. Confini uguali significano intervallo vuoto. Durante il periodo tranquillo, Main finisce; La funzione è data nella sua interezza.

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(ClockInWindow(UO.Time(), 230000, 20000)))
        {
            UO.Print("Local quiet period; do not start a new batch");
            return null;
        }

        UO.Print("Outside the local quiet period");
        return null;
    }

    dynamic ClockInWindow(dynamic stamp, dynamic first, dynamic last)
    {
        if (Truth(first == last))
        {
            return false;
        }

        if (Truth(first < last))
        {
            return Truth(stamp >= first) && Truth(stamp < last);
        }

        return Truth(stamp >= first) || Truth(stamp < last);
    }

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

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.Time.

Codice interno di implementazione; non è uno script autonomo.

public int Time()

        {

            var now = timeSource.Now;

            return now.Hour * 10000 + now.Minute * 100 + now.Second;

        }

---

UO.Timer

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

Firme C#

int UO.Timer();

Legge il tempo di esecuzione del runtime corrente in decimi di secondo. Adatto per i tuoi ritardi e segni di azione.

Parametri

Non ci sono parametri.

Valore restituito

int 0..2147483647; l'unità è 100 ms. A 399 ms verrà restituito 3. Questa è la lettura dell'orologio, non true/false e non la ricarica rimanente.

Comportamento

• Non ci sono parametri, né moduli con argomenti. Le parentesi vuote leggono solo l'ora: la chiamata non attende, non avvia un timer o non invia pacchetti al gioco.
• L'origine appartiene a questa istanza di runtime. Una nuova procedura in esecuzione può ricevere un nuovo orologio; Non è possibile confrontare valori di esecuzioni diverse o memorizzarli come data assoluta. Durante UO.Wait e una pausa dello script, il tempo reale continua a ticchettare.
• La parte frazionaria dei decimi viene scartata. Dopo circa 2485.5 giorni il numero raggiunge 2147483647 e rimane lì senza traboccare.
• Questo è il tuo ritardo, non il raffreddamento del server di un'abilità/incantesimo o una conferma di successo. Il comando non ti consente di aggirare le restrizioni del server su movimento, incantesimi o script.

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

1. Misurare la durata di un'operazione - script diretto

Parametri e flusso di esecuzione:

• WaitAsync(250) richiede 250 ms; il ritardo effettivo potrebbe essere più lungo. La differenza tra i due voti viene divisa per 10.0 per ottenere i secondi. Passo di indicazione UO.Timer - 100 ms.

var started = UO.Timer();
await Delay(250);
var elapsed = UO.Timer() - started;
var seconds = elapsed / 10.0;
UO.Print("Elapsed seconds: " + Convert.ToString(seconds));

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

2. Limita a tre secondi l'attesa per un mirino già richiesto - funzione script

Parametri e flusso di esecuzione:

• Il limite 30 è dato in unità di questa funzione. UO.Wait(50) releases execution between checks. UO.Targeting reads the presence of a sight; example does not cast or target. If the sight does not appear, the cycle ends.
• Un ulteriore controllo del limite superiore pone fine all'attesa anche se il contatore si è fermato al limite int. Lo stato dell'oscilloscopio viene letto ripetutamente e può cambiare tra una lettura e l'altra.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var started = UO.Timer();
    while (Truth(UO.Timer() - started < 30) && !(Truth(UO.Targeting())))
    {
        if (Truth(UO.Timer() >= 2147483647))
        {
            break;
        }

        await Delay(50);
    }

    if (Truth(UO.Targeting()))
    {
        UO.Print("Target cursor available");
    }
    else
    {
        UO.Print("Target wait ended");
    }

    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. Funzione intervallo tentativi personalizzato - Classe script

Parametri e flusso di esecuzione:

• IntervalPassed(iniziato,corrente,intervallo) è completamente definito in Main. interval=5 — mezzo secondo in unità di questo orologio. L'intervallo negativo, l'inversione e int sul limite superiore danno false; raggiungendo esattamente l'intervallo si ottiene true.
• Questo è il tuo ritardo, non il raffreddamento del server di un'abilità/incantesimo o una conferma di successo. Il comando non ti consente di aggirare le restrizioni del server su movimento, incantesimi o script.

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 started = UO.Timer();
        await Delay(500);
        var ready = IntervalPassed(started, UO.Timer(), 5);
        if (Truth(ready))
        {
            UO.Print("Local retry interval passed");
        }

        return null;
    }

    dynamic IntervalPassed(dynamic started, dynamic current, dynamic interval)
    {
        if (Truth(interval < 0) || Truth(current < started))
        {
            return false;
        }

        if (Truth(current >= 2147483647))
        {
            return false;
        }

        return current - started >= interval;
    }

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

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.Timer.

Codice interno di implementazione; non è uno script autonomo.

public int Timer() => (int)Math.Max(0d, Math.Min(int.MaxValue, timeSource.SinceStart.TotalMilliseconds / 100d));

---

UO.Wait

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

Firme C#

void UO.Wait(object? waitTimeMS);

Mette in pausa lo script corrente per il numero specificato di millisecondi. Utile tra controlli di stato ripetuti per impedire l'esecuzione dello script in un ciclo continuo.

Parametri

• waitTimeMS — Tempo intero in millisecondi: 1000 = un secondo. Usa 0..2147483647. Questo non è il numero di passaggi, non i secondi e non il timeout di conferma del server.

Valore restituito

void - nessun risultato. Chiama su una linea separata. La fine del ritardo non significa che l'oggetto si è spostato, l'incantesimo si è concluso o la connessione è stata stabilita: verifica separatamente lo stato desiderato.

Comportamento

• Lo zero non crea alcun ritardo reale e non è adatto come pausa in un ciclo veloce. Il tempo negativo non significa infinito: UO.Wait lo riduce a 0; UO.Wait/sleep può rifiutarlo con callback attivi e nel bridge client senza di essi non aspetterà. Per uno script portabile, utilizzare solo tempi non negativi.

Esempio .csx

UO.Wait(100);
// For an asynchronous script, use the host helper:
await WaitAsync(100);

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

1. UO.Wait - 1 - sceneggiatura diretta

Parametri e flusso di esecuzione:

• 250 - quarto di secondo. La riga successiva viene eseguita dopo l'attesa; Il messaggio Ritardo completamento è il testo dell'esempio, non il risultato restituito.

UO.Wait(250);
UO.Print("Delay complete");

2. UO.Wait — 2 — funzione di script

Parametri e flusso di esecuzione:

• WaitForOnline è completamente dichiarato in questo script. L'argomento 20 significa un massimo di venti pause di 250 ms. La connessione viene controllata prima delle pause e nuovamente dopo l'ultima. L'aiutante restituisce lo stato Connected (1/0); Il comando wait stesso non restituisce nulla e non si connette al server.

return  RunScenario();
 object? RunScenario()
{
    return WaitForOnline(20);
    return null;
}

dynamic WaitForOnline(dynamic checks)
{
    while (Truth(checks > 0))
    {
        if (Truth(UO.Connected()))
        {
            return 1;
        }

        UO.Wait(250);
        checks = checks - 1;
    }

    return UO.Connected();
}

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

3. UO.Wait - 3 - classe dello scenario

Parametri e flusso di esecuzione:

• Il circuito effettua esattamente tre letture del peso. Tra le letture ci sono due pause di 500 ms, dopo l'ultima non c'è pausa. Viene stampato un messaggio la prima volta che viene letto e quando cambia il peso. La variabile precedente memorizza il valore da confrontare, anziché regolare il peso del gioco.

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 previous = -1;
        var checks = 0;
        while (Truth(checks < 3))
        {
            var weight = UO.Weight();
            if (Truth(weight != previous))
            {
                UO.Print("Weight: " + Convert.ToString(weight));
                previous = weight;
            }

            checks = checks + 1;
            if (Truth(checks < 3))
            {
                UO.Wait(500);
            }
        }

        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.Wait(waitTimeMS) — UO.Wait(Any)

Parametri: waitTimeMS (Any)

Risultato: void / Unit.

Durante la chiamata:

• ClassicUO.CSharp.CSharpScriptGlobals.WaitAsync.
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• InjectionScript.Runtime.InjectionApiUO.WaitWithEvents: WaitWithEvents(Arg(0)).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).

Codice interno di implementazione; non è uno script autonomo.

public async Task WaitAsync(int milliseconds)
    {
        ArgumentOutOfRangeException.ThrowIfNegative(milliseconds);
        Checkpoint();
        // Short slices allow Pause to suspend further script progress promptly.
        int remaining = milliseconds;
        while (remaining > 0)
        {
            int slice = Math.Min(remaining, 25);
            await Task.Delay(slice, Cancellation).ConfigureAwait(false);
            Checkpoint(); remaining -= slice;
        }
    }

Codice interno di implementazione; non è uno script autonomo.

case "wait": WaitWithEvents(Arg(0)); return InjectionValue.Unit;

---

UO.Waiting

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

Firme C#

int UO.Waiting();

Controlla se le risposte preparate rimangono nella coda di destinazione.

Parametri

Non ci sono parametri.

Valore restituito

int 1 - c'è un bersaglio differito non cancellato di un oggetto, tessera o cancellazione della vista successiva; 0 - la coda è vuota. Non ha un cursore aperto; per il cursore utilizzare TargetPresent/Targeting.

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

Comportamento

• Viene letta l'intera coda del client. Se più procedure sono in esecuzione contemporaneamente, vengono prese in considerazione le risposte di ciascuna di esse.
• Zero significa solo che non c'è alcuna risposta in sospeso. Non conferma l'uso riuscito di un'abilità o di un incantesimo sul server.

Script C# autonomi

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

Esempio semplice

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

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

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

1. Controlla la preparazione - sceneggiatura diretta

Parametri e flusso di esecuzione:

• Dopo WaitTargetSelf e prima è previsto il server di destinazione 1.
• CancelWaitTarget cancella la coda; il test successivo dà 0.

UO.WaitTargetSelf();
UO.Print(Convert.ToString(UO.Waiting()));
UO.CancelWaitTarget();

2. Attendere indefinitamente che la risposta venga spesa - funzione script

Parametri e flusso di esecuzione:

• Il controllo non ha parametri. UO.Wait=50 ms, aspettative massime di 20.
• Se la risposta rimane, viene annullata. Aggiungi un controllo separato per il risultato dell'azione del server.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var attempts = 0;
    while (Truth(UO.Waiting()) && Truth(attempts < 20))
    {
        await Delay(50);
        attempts = attempts + 1;
    }

    if (Truth(UO.Waiting()))
    {
        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. Mostra la differenza tra coda e vista - classe di script

Parametri e flusso di esecuzione:

• La prima riga mostra le risposte differite, la seconda lo stato della vista.
• Sono possibili una coda senza cursore e un cursore senza coda; questi valori non sono intercambiabili.

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.Print("Queued: " + Convert.ToString(UO.Waiting()));
        UO.Print("Cursor: " + Convert.ToString(UO.TargetPresent()));
        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.Waiting() — UO.Waiting()

Parametri: Nessun parametro.

Risultato: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.Waiting.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetWaitTargetQueue: bridge.GetWaitTargetQueue().

Codice interno di implementazione; non è uno script autonomo.

public int Waiting() => bridge.GetWaitTargetQueue().Length > 0 ? 1 : 0;