ES UO Topic scripts runtime

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

Guiones y tiempo de ejecución

Inicio · C# · IDE · UO API · A–Z · Ejemplos · Idiomas

Iniciar, pausar, detener scripts y procedimientos, información de instancia, eventos y esperar. Terminate y StopScript operan en diferentes niveles de ejecución.

Secciones

Tema	Comandos y explicaciones
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

Todos los comandos del tema

Ciclo de vida del guión

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

Trámites / Eventos

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

Temporizadores / Waiting

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

Disconnect Comportamiento

UO.GetPauseScriptOnDisconnectStatus · UO.SetPauseScriptOnDisconnectStatus

Ejemplos sobre el tema.

Cada tarjeta de comando tiene varios escenarios independientes: código directo, funciones y clases. A continuación se muestran escenarios breves seleccionados; restricciones y análisis completos están en las cartas.

UO.GetScriptsList

Parámetros, resultado y todos los escenarios

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

UO.TerminateAll

Parámetros, resultado y todos los escenarios

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;

Referencia completa de comandos

---

UO.CallSub

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

Firmas de C#

void UO.CallSub(object? subrutineName);

Lanza el delegado C# previamente registrado en la ejecución actual mediante RegisterRoutine(nombre, controlador). La llamada devuelve el control antes de que complete el ayudante; Una tarea registrada no se puede imponer a sí misma.

Parámetros

• subrutineName es el nombre de cadena dado por RegisterRoutine. Se eliminan los espacios en blanco alrededor de los bordes; Las búsquedas de nombres registrados no distinguen entre mayúsculas y minúsculas.

Valor devuelto

void - sin resultado; un nombre desconocido CallSub provoca un error y se omite volver a ejecutar un nombre ya activo.

Comportamiento

UO.FunRunning(name) == 0 también puede ocurrir inmediatamente después de solicitar la cancelación. No significa que el callback anterior haya terminado su bloque finally. Otro CallSub o Exec para el mismo nombre local se omite hasta que el trabajador anterior termina realmente.

• El registro y las tareas pertenecen a la misma ejecución. Otro personaje, perfil o ejecución posterior tiene su propio registro.
• RegisterRoutine acepta Action, Func<Task> o un delegado con una serie de argumentos de cadena para Exec. Eliminar el registro no ejecuta el código e impide realizar más búsquedas del nombre.
• El script principal debe permanecer activo mientras se necesitan sus ayudantes: una vez finalizado, las tareas se cancelan y se liberan los registros y suscripciones.
• FunRunning no es un índice de administrador. GetScriptsList y GetScriptState describen lanzamientos de archivos independientes; la devolución de llamada local no recibe un índice separado.
• El error de devolución de llamada se pasa al script principal en la siguiente verificación. Los bucles WaitAsync, UO.Wait y C# instrumentados admiten pausa, cancelación y procesamiento de cola de eventos.

Archivos C# cargados

Además de los delegados locales, el administrador actual admite entradas C# cargadas explícitamente con una clave como Child.csx::Main. SubExists y FunRunning aceptan dicha clave; CallSub ejecuta el archivo sin Args y Exec("exec Child.csx::Main 'north gate' 42") pasa Args. La clave con espacios está entre comillas dentro de Exec. Se acepta un nombre corto único, un nombre ambiguo no selecciona un archivo aleatorio. El registro local tiene prioridad. El lanzamiento de un archivo obtiene su propio contexto y duración en el mundo/administrador actual; Los delegados locales pertenecen a la ejecución que los registró.

Scripts independientes de C#

Cada ejemplo se puede guardar como un archivo independiente .csx y ejecutar en IDE. Las funciones de objeto UO y de espera proporcionan el anfitrión de la sesión de juego actual. Reemplace los nombres, coordenadas y direcciones de la demostración serial por los suyos propios.

Ejemplo sencillo

Ejecuta este código en un archivo .csx independiente. Los argumentos aparecen en la llamada; sustituye los nombres, seriales y direcciones de ejemplo por los tuyos.

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

1. Iniciar observador y continuar Principal - guión directo

Parámetros y flujo de ejecución:

• WeightWatch es el nombre del procedimiento siguiente. Main regresa 77 sin esperar tres muestras; 77 es el resultado de Main, no CallSub.
• Guarde el ejemplo como un archivo separado, cárguelo en IDE/manager y ejecute Main para que el resto de los procedimientos terminen en el directorio. WeightWatch/ManaWatch - procedimientos de entrenamiento completamente definidos aquí: tres mediciones de peso/mana con un intervalo de UO.Wait(1000), es decir, 1000 ms, salida solo al entrar al mundo. Este no es un monitoreo continuo; una pausa puede prolongar el tiempo. Para el ejemplo con dos tareas, se debe permitir el inicio simultáneo de procedimientos.

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. No reiniciar una tarea activa o suspendida - función de script

Parámetros y flujo de ejecución:

• StartIfIdle verifica primero la definición y luego la actividad. false significa que la solicitud no fue enviada. true significa que solo se envió la solicitud CallSub, no la confirmación de inicio o finalización.
• Guarde el ejemplo como un archivo separado, cárguelo en IDE/manager y ejecute Main para que el resto de los procedimientos terminen en el directorio. WeightWatch/ManaWatch - procedimientos de entrenamiento completamente definidos aquí: tres mediciones de peso/mana con un intervalo de UO.Wait(1000), es decir, 1000 ms, salida solo al entrar al mundo. Este no es un monitoreo continuo; una pausa puede prolongar el tiempo. Para el ejemplo con dos tareas, se debe permitir el inicio simultáneo de procedimientos.

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. Dos observadores independientes: clase de escenario

Parámetros y flujo de ejecución:

• El primer CallSub comienza con WeightWatch, el segundo - ManaWatch. Las ejecuciones son independientes y no intercambian variables locales; el orden de su salida no está garantizado.
• Guarde el ejemplo como un archivo separado, cárguelo en IDE/manager y ejecute Main para que el resto de los procedimientos terminen en el directorio. WeightWatch/ManaWatch - procedimientos de entrenamiento completamente definidos aquí: tres mediciones de peso/mana con un intervalo de UO.Wait(1000), es decir, 1000 ms, salida solo al entrar al mundo. Este no es un monitoreo continuo; una pausa puede prolongar el tiempo. Para el ejemplo con dos tareas, se debe permitir el inicio simultáneo de procedimientos.

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);
}

Implementación del comando

C# distingue mayúsculas y minúsculas. Use el nombre UO exacto. Compare indicadores numéricos con 0; use bool solo si la firma devuelve bool.

UO.CallSub(subrutineName) — UO.CallSub(String)

Parámetros: subrutineName (String)

Resultado: void / Unit.

Durante la llamada:

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

Código interno de implementación; no es un script independiente.

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;

Código interno de implementación; no es un script independiente.

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

---

UO.Date

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

Firmas de C#

int UO.Date();

Lee la fecha del calendario local de la computadora con el número YYMMDD. Útil para nombrar una serie diaria de actividades o detectar cambios de fecha.

Parámetros

No hay parámetros.

Valor devuelto

int YYMMDD: 2026-09-30 -> 260930. No se almacenan delimitadores ni ceros a la izquierda. No es la duración, ni el tiempo de Unix, ni true/false.

Comportamiento

• No hay parámetros, ni formularios con argumentos. Los paréntesis vacíos solo leen la hora: la llamada no espera, no inicia un cronómetro ni envía paquetes al juego.
• RealTimeSource. Ahora se lee DateTime. Ahora: la fecha/hora local de la computadora, no UTC, ni la hora del fragmento ni el reloj del juego. La zona horaria, el horario de verano y el cambio manual del reloj afectan los resultados. Cada llamada captura un momento diferente.
• Solo se conservan los dos últimos dígitos del año: tanto 2000-01-01 como 2100-01-01 dan 101. Los diferentes siglos no son diferentes. Las llamadas individuales Date y Time pueden aterrizar en lados opuestos de la medianoche.
• No reste los códigos del calendario para calcular el retraso. Utilice Timer() y dos marcas de una ejecución. El reloj del calendario puede retroceder.

Scripts independientes de C#

Cada ejemplo se puede guardar como un archivo independiente .csx y ejecutar en IDE. Las funciones de objeto UO y de espera proporcionan el anfitrión de la sesión de juego actual. Reemplace los nombres, coordenadas y direcciones de la demostración serial por los suyos propios.

Ejemplo sencillo

Ejecuta este código en un archivo .csx independiente. Los argumentos aparecen en la llamada; sustituye los nombres, seriales y direcciones de ejemplo por los tuyos.

El resultado de una sola llamada se muestra en el diario. Un número no se convierte en bool; para un array se muestra su cantidad de elementos.

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

1. Nombra la serie de recopilación diaria de recursos: guión directo

Parámetros y flujo de ejecución:

• El resultado de la llamada sin parámetros se guarda una vez. sessionLabel es una cadena como cosecha-260930. Print solo muestra el nombre: el archivo no se crea, la recopilación de recursos no comienza.

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

2. Finalizar serie cuando cambia el día local: función de script

Parámetros y flujo de ejecución:

• originalDate almacena la fecha original. Timer limita la observación a 60 segundos, UO.Wait(1000) comprueba aproximadamente una vez por segundo. El cambio de fecha finaliza en Principal. El ejemplo no espera indefinidamente hasta la medianoche y no afirma que el día haya cambiado en el servidor.

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. Seleccione año, mes y día - clase de guión

Parámetros y flujo de ejecución:

• MonthPart(sello) se muestra en su totalidad: división redondeada hacia abajo y MOD 100 extrae el mes. día: dos últimos dígitos; shortYear—año incompleto. Para 260930 obtenemos 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;
    }
}

Implementación del comando

C# distingue mayúsculas y minúsculas. Use el nombre UO exacto. Compare indicadores numéricos con 0; use bool solo si la firma devuelve bool.

UO.Date() — UO.Date()

Parámetros: Sin parámetros.

Resultado: int / Integer.

Durante la llamada:

• InjectionScript.Runtime.InjectionApiUO.Date.

Código interno de implementación; no es un script independiente.

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 · 繁體中文 · 日本語 · 한국어

Firmas de C#

void UO.Exec(object? parameters);

Ejecuta un comando de juego de texto o ejecuta un delegado C# registrado o un archivo C# cargado.

Parámetros

• parameters - cadena de comando: por ejemplo, "useskill Hiding", "exec Worker 42" o "exec Child.csx::Main 'north gate' 42". Una expresión C# como 2+3 dentro de una cadena no se evalúa automáticamente.

Valor devuelto

void: sin resultado. La devolución del control no significa el final del inicio o la confirmación de la acción del juego por parte del servidor.

Comportamiento

UO.FunRunning(name) == 0 también puede ocurrir inmediatamente después de solicitar la cancelación. No significa que el callback anterior haya terminado su bloque finally. Otro CallSub o Exec para el mismo nombre local se omite hasta que el trabajador anterior termina realmente.

• Primero se verifica el registro local RegisterRoutine. Se admiten "Name args", "exec Name args" y "_exec Name args". El delegado recibe string[]: el argumento 42 sigue siendo la cadena "42" y '00123' conserva los ceros a la izquierda. Las comillas simples o dobles concatenan un argumento con espacios; '' especifica una cadena vacía. Una cotización no cerrada provoca un error. En esta ruta, la barra invertida se mantiene literalmente; No utilice la sintaxis de escape C# dentro del texto de comando escrito previamente.
• El delegado local se ejecuta de forma asincrónica. Para esperar a que termine, use FunRunning y WaitAsync. Reiniciar el nombre activo no crea una copia y no elimina la pausa. El error de ayuda se pasa al script principal en el punto de control.
• El administrador actual inicia las entradas de archivos cargadas explícitamente con su propio Args y duración. El solo hecho de aceptar la solicitud de inicio no significa que el archivo haya terminado de funcionar.
• Los comandos habituales del juego se pasan al despachador nativo. Allí se guardan los contratos de parámetros del correspondiente comando UO; Print/Msg/Say/ConsolePrint/TextPrint combina el resto de la línea en texto. Para tipos y expresiones C# precisos, utilice una llamada directa como UO.UseSkill("Hiding"). Un comando desconocido, argumentos no válidos o comillas pueden provocar que try/catch detecte una excepción.
• Alias ​​de consola: sayu → Say, closeuo → CloseHandle, CountOnGround → CountGround, clearignorelist → IgnoreReset, canceltarget → CancelTarget, cancelmove → MoveOff.

Archivos C# cargados

Además de los delegados locales, el administrador actual admite entradas C# cargadas explícitamente con una clave como Child.csx::Main. SubExists y FunRunning aceptan dicha clave; CallSub ejecuta el archivo sin Args y Exec("exec Child.csx::Main 'north gate' 42") pasa Args. La clave con espacios está entre comillas dentro de Exec. Se acepta un nombre corto único, un nombre ambiguo no selecciona un archivo aleatorio. El registro local tiene prioridad. El lanzamiento de un archivo obtiene su propio contexto y duración en el mundo/administrador actual; Los delegados locales pertenecen a la ejecución que los registró.

Scripts independientes de C#

Cada ejemplo se puede guardar como un archivo independiente .csx y ejecutar en IDE. Las funciones de objeto UO y de espera proporcionan el anfitrión de la sesión de juego actual. Reemplace los nombres, coordenadas y direcciones de la demostración serial por los suyos propios.

Ejemplo sencillo

Ejecuta este código en un archivo .csx independiente. Los argumentos aparecen en la llamada; sustituye los nombres, seriales y direcciones de ejemplo por los tuyos.

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

1. Usar la habilidad seleccionada - guión directo

Parámetros y flujo de ejecución:

• Ocultar es el único argumento para UseSkill. Al ingresar al mundo, el cliente envía una solicitud para usar la habilidad; el éxito de la ocultación lo determina el servidor. Mismo funcionamiento mediante llamada directa: UO.UseSkill("Hiding").

UO.Exec("useskill Hiding");

2. Pasar la etiqueta de cadena al procedimiento local: función de script

Parámetros y flujo de ejecución:

• SelectSavedRoute se define a continuación y registra el nombre de la ruta seleccionada. Las comillas alrededor de 00123 conservan los ceros a la izquierda. Exec ejecuta el delegado registrado de forma asincrónica. El bucle con FunRunning y WaitAsync espera explícitamente a que finalice y luego el script devuelve la cadena 00123. Este es un nombre de entrenamiento guardado, no un comando de movimiento.

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. Ejecutar un observador independiente: clase de secuencia de comandos

Parámetros y flujo de ejecución:

• Ejecute este script C#: RegisterRoutine asocia el nombre WeightWatch con la función declarada de la ejecución actual. exec WeightWatch inicia tres mediciones de peso en intervalos 1000 ms y no espera a que se completen. El script principal permanece activo mientras se ejecuta el asistente local; El asistente no tiene un índice de administrador separado. Si la tarea ya está en pausa, Exec nuevamente no la reanuda.

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. Cargar script desde una carpeta con espacios - script directo

Parámetros y flujo de ejecución:

• Reemplace la ruta con el archivo C# existente con su procedimiento principal. startscript carga el archivo y le pide a Main que lo ejecute. Las comillas pertenecen al comando de texto; se conservan las barras invertidas de ruta. Consulte IDE para conocer los errores de inicio, ya que Exec no devuelve una confirmación.

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

Implementación del comando

C# distingue mayúsculas y minúsculas. Use el nombre UO exacto. Compare indicadores numéricos con 0; use bool solo si la firma devuelve bool.

UO.Exec(parameters) — UO.Exec(String)

Parámetros: parameters (String)

Resultado: void / Unit.

Durante la llamada:

• 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).

Código interno de implementación; no es un script independiente.

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;

Código interno de implementación; no es un script independiente.

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 · 繁體中文 · 日本語 · 한국어

Firmas de C#

int UO.FunRunning(object? subrutineName);

Comprueba si se ejecuta la devolución de llamada C# registrada con el nombre especificado. El resultado 1 habilita la pausa manual; una tarea completada o cancelada da 0.

Parámetros

• subrutineName es el nombre de cadena dado por RegisterRoutine. Se eliminan los espacios en blanco alrededor de los bordes; Las búsquedas de nombres registrados no distinguen entre mayúsculas y minúsculas.

Valor devuelto

int: 1 - se cumple la condición, 0 - no se cumple. Guarde el resultado de una llamada si varias comprobaciones lo necesitan.

Comportamiento

UO.FunRunning(name) == 0 también puede ocurrir inmediatamente después de solicitar la cancelación. No significa que el callback anterior haya terminado su bloque finally. Otro CallSub o Exec para el mismo nombre local se omite hasta que el trabajador anterior termina realmente.

• El registro y las tareas pertenecen a la misma ejecución. Otro personaje, perfil o ejecución posterior tiene su propio registro.
• RegisterRoutine acepta Action, Func<Task> o un delegado con una serie de argumentos de cadena para Exec. Eliminar el registro no ejecuta el código e impide realizar más búsquedas del nombre.
• El script principal debe permanecer activo mientras se necesitan sus ayudantes: una vez finalizado, las tareas se cancelan y se liberan los registros y suscripciones.
• FunRunning no es un índice de administrador. GetScriptsList y GetScriptState describen lanzamientos de archivos independientes; la devolución de llamada local no recibe un índice separado.
• El error de devolución de llamada se pasa al script principal en la siguiente verificación. Los bucles WaitAsync, UO.Wait y C# instrumentados admiten pausa, cancelación y procesamiento de cola de eventos.

Archivos C# cargados

Además de los delegados locales, el administrador actual admite entradas C# cargadas explícitamente con una clave como Child.csx::Main. SubExists y FunRunning aceptan dicha clave; CallSub ejecuta el archivo sin Args y Exec("exec Child.csx::Main 'north gate' 42") pasa Args. La clave con espacios está entre comillas dentro de Exec. Se acepta un nombre corto único, un nombre ambiguo no selecciona un archivo aleatorio. El registro local tiene prioridad. El lanzamiento de un archivo obtiene su propio contexto y duración en el mundo/administrador actual; Los delegados locales pertenecen a la ejecución que los registró.

Scripts independientes de C#

Cada ejemplo se puede guardar como un archivo independiente .csx y ejecutar en IDE. Las funciones de objeto UO y de espera proporcionan el anfitrión de la sesión de juego actual. Reemplace los nombres, coordenadas y direcciones de la demostración serial por los suyos propios.

Ejemplo sencillo

Ejecuta este código en un archivo .csx independiente. Los argumentos aparecen en la llamada; sustituye los nombres, seriales y direcciones de ejemplo por los tuyos.

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. Ejecutar observador registrado sin superposición: script directo

Parámetros y flujo de ejecución:

• Primero, RegisterRoutine asocia el nombre con la función C#. FunRunning comprueba la tarea de esta ejecución, incluida la pausa. El script principal permanece activo hasta que se completa el asistente.

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. Espere a que finalice y lea el resultado del trabajo en segundo plano: función de secuencia de comandos

Parámetros y flujo de ejecución:

• El delegado asíncrono cambia el contador compartido mediante Interlocked. Después de FunRunning=0, el resultado se lee hasta Volatile. Esta es una devolución de llamada local; no tiene un índice separado 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. Cancelar ayudante asíncrono registrado - clase de script

Parámetros y flujo de ejecución:

• Terminate selecciona la tarea registrada de la ejecución actual. Esperando a que WaitAsync use su token de cancelación. finally realiza la limpieza; No se permiten más acciones de juego de la tarea cancelada.

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);
}

Implementación del comando

C# distingue mayúsculas y minúsculas. Use el nombre UO exacto. Compare indicadores numéricos con 0; use bool solo si la firma devuelve bool.

UO.FunRunning(subrutineName) — UO.FunRunning(String)

Parámetros: subrutineName (String)

Resultado: int / Integer.

Durante la llamada:

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

Código interno de implementación; no es un script independiente.

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

Código interno de implementación; no es un script independiente.

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

---

UO.GetPauseScriptOnDisconnectStatus

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

Firmas de C#

dynamic UO.GetPauseScriptOnDisconnectStatus();

Lee la configuración de pausa del script cuando el administrador está deshabilitado.

Parámetros

No hay parámetros.

Valor devuelto

int 1 — PauseScriptsOnDisconnect habilitado; 0 - deshabilitado.

Comportamiento

• Lee la bandera del administrador, no la pausa actual de un script individual. La llamada en sí no se detiene ni se reanuda.

Scripts independientes de C#

Cada ejemplo se puede guardar como un archivo independiente .csx y ejecutar en IDE. Las funciones de objeto UO y de espera proporcionan el anfitrión de la sesión de juego actual. Reemplace los nombres, coordenadas y direcciones de la demostración serial por los suyos propios.

Ejemplo sencillo

Ejecuta este código en un archivo .csx independiente. Los argumentos aparecen en la llamada; sustituye los nombres, seriales y direcciones de ejemplo por los tuyos.

El resultado de una sola llamada se muestra en el diario. Un número no se convierte en bool; para un array se muestra su cantidad de elementos.

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

1. Configuración de lectura: guión directo

Parámetros y flujo de ejecución:

• El valor describe la configuración del administrador.

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

2. Verifique por separado la conexión - función de script

Parámetros y flujo de ejecución:

• El indicador de configuración y la conexión se leen de forma independiente.

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

3. Guardar valor: clase de secuencia de comandos

Parámetros y flujo de ejecución:

• La variable contiene una instantánea de la configuración en el momento de la lectura.

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)));
}

Implementación del comando

C# distingue mayúsculas y minúsculas. Use el nombre UO exacto. Compare indicadores numéricos con 0; use bool solo si la firma devuelve bool.

UO.GetPauseScriptOnDisconnectStatus() — UO.GetPauseScriptOnDisconnectStatus()

Parámetros: Sin parámetros.

Resultado: dynamic / Any.

Durante la llamada:

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

Código interno de implementación; no es un script independiente.

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

---

UO.GetScriptName

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

Firmas de C#

string UO.GetScriptName(object? scriptIndex);

Lee el nombre para mostrar de la ejecución activa.

Parámetros

• scriptIndex - Obligatorio ScriptIndex - número entero, índice desde cero desde nuevo GetScriptsList. Para un índice negativo o faltante, se devuelve el resultado vacío/desconocido descrito. No pase serial del tema, el nombre del procedimiento, o ID del lanzamiento de IDE.

Valor devuelto

string: nombre para mostrar o "" si no hay índice. Un lanzamiento existente también puede tener su nombre establecido explícitamente en la cadena vacía.

Comportamiento

• Se tienen en cuenta los lanzamientos en ejecución y en pausa; Se excluyen aquellos completados y que hayan recibido una solicitud de cancelación. Un script en ejecución generalmente se tiene en cuenta a sí mismo. Simplemente cargar la pestaña IDE no se considera un inicio.
• Los índices son las posiciones actuales en orden de inicio. Iniciar/detener guiones puede cambiar de posición. Diferentes llamadas no forman una instantánea atómica común; Vuelva a leer la lista antes del siguiente comando de control.
• GetScriptsList da los índices, GetScriptsCount la cantidad, GetScriptState el código de tres estados. No sustituya uno por otro ni trate ningún resultado distinto de cero como el valor de true.
• ScriptIndex=0: el primer inicio actual, que no necesariamente llama al script. SetScriptName cambia el nombre para mostrar sin cambiar el nombre del archivo.

Scripts independientes de C#

Cada ejemplo se puede guardar como un archivo independiente .csx y ejecutar en IDE. Las funciones de objeto UO y de espera proporcionan el anfitrión de la sesión de juego actual. Reemplace los nombres, coordenadas y direcciones de la demostración serial por los suyos propios.

Ejemplo sencillo

Ejecuta este código en un archivo .csx independiente. Los argumentos aparecen en la llamada; sustituye los nombres, seriales y direcciones de ejemplo por los tuyos.

El resultado de una sola llamada se muestra en el diario. Un número no se convierte en bool; para un array se muestra su cantidad de elementos.

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

1. Primera convocatoria y resultado - guión directo

Parámetros y flujo de ejecución:

• Ejecute el script C# proporcionado. El número 0, donde se pasa, denota el índice; Los paréntesis vacíos significan que no hay argumentos. El texto Print es solo un mensaje de ejemplo.
• ScriptIndex=0: el primer inicio actual, que no necesariamente llama al script. SetScriptName cambia el nombre para mostrar sin cambiar el nombre del archivo.
• string: nombre para mostrar o "" si no hay índice. Un lanzamiento existente también puede tener su nombre establecido explícitamente en la cadena vacía.
• Obligatorio ScriptIndex es un número entero, índice desde cero del nuevo GetScriptsList. Para un índice negativo o faltante, se devuelve el resultado vacío/desconocido descrito. No pase serial del elemento, el nombre del procedimiento o ID del lanzamiento desde IDE.

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

2. Uso en un bucle o condición: función de script

Parámetros y flujo de ejecución:

• Este es un ejemplo específico de uso compartido de comandos. La indexación de matrices comienza desde cero; Comprueba la longitud antes de manipularlo. UO.Wait(250), donde se usa, espera 250 milisegundos.
• ScriptIndex=0: el primer inicio actual, que no necesariamente llama al script. SetScriptName cambia el nombre para mostrar sin cambiar el nombre del archivo.
• string: nombre para mostrar o "" si no hay índice. Un lanzamiento existente también puede tener su nombre establecido explícitamente en la cadena vacía.
• Obligatorio ScriptIndex es un número entero, índice desde cero del nuevo GetScriptsList. Para un índice negativo o faltante, se devuelve el resultado vacío/desconocido descrito. No pase serial del elemento, el nombre del procedimiento o ID del lanzamiento desde 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. Función auxiliar completa: clase de script

Parámetros y flujo de ejecución:

• Debajo de Main está la función completa. Sus parámetros y resultados se explican por separado del comando API que llama.
• DescribeScript verifica el estado y concatena el nombre con la ruta. Es posible hacer una pausa entre llamadas; "Falta" es el valor de nuestra función, no el resultado de GetScriptName.
• string: nombre para mostrar o "" si no hay índice. Un lanzamiento existente también puede tener su nombre establecido explícitamente en la cadena vacía.
• Obligatorio ScriptIndex es un número entero, índice desde cero del nuevo GetScriptsList. Para un índice negativo o faltante, se devuelve el resultado vacío/desconocido descrito. No pase serial del elemento, el nombre del procedimiento o ID del lanzamiento desde 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;
}

Implementación del comando

C# distingue mayúsculas y minúsculas. Use el nombre UO exacto. Compare indicadores numéricos con 0; use bool solo si la firma devuelve bool.

UO.GetScriptName(scriptIndex) — UO.GetScriptName(Any)

Parámetros: scriptIndex (Any)

Resultado: string / String.

Durante la llamada:

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

Código interno de implementación; no es un script independiente.

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

---

UO.GetScriptPath

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

Firmas de C#

string UO.GetScriptPath(object? scriptIndex);

Lee la ruta del archivo fuente de inicio activo.

Parámetros

• scriptIndex - Obligatorio ScriptIndex - número entero, índice desde cero desde nuevo GetScriptsList. Para un índice negativo o faltante, se devuelve el resultado vacío/desconocido descrito. No pase serial del tema, el nombre del procedimiento, o ID del lanzamiento de IDE.

Valor devuelto

string: ruta guardada del archivo fuente o "" si no hay índice. Al ejecutar el archivo, esta suele ser la ruta completa; Es posible que el comando o la fuente no tenga un archivo normal en la memoria.

Comportamiento

• Se tienen en cuenta los lanzamientos en ejecución y en pausa; Se excluyen aquellos completados y que hayan recibido una solicitud de cancelación. Un script en ejecución generalmente se tiene en cuenta a sí mismo. Simplemente cargar la pestaña IDE no se considera un inicio.
• Los índices son las posiciones actuales en orden de inicio. Iniciar/detener guiones puede cambiar de posición. Diferentes llamadas no forman una instantánea atómica común; Vuelva a leer la lista antes del siguiente comando de control.
• GetScriptsList da los índices, GetScriptsCount la cantidad, GetScriptState el código de tres estados. No sustituya uno por otro ni trate ningún resultado distinto de cero como el valor de true.
• ScriptIndex=0 selecciona la primera ejecución actual. El resultado indica su fuente; el comando no abre, guarda ni ejecuta este archivo.

Scripts independientes de C#

Cada ejemplo se puede guardar como un archivo independiente .csx y ejecutar en IDE. Las funciones de objeto UO y de espera proporcionan el anfitrión de la sesión de juego actual. Reemplace los nombres, coordenadas y direcciones de la demostración serial por los suyos propios.

Ejemplo sencillo

Ejecuta este código en un archivo .csx independiente. Los argumentos aparecen en la llamada; sustituye los nombres, seriales y direcciones de ejemplo por los tuyos.

El resultado de una sola llamada se muestra en el diario. Un número no se convierte en bool; para un array se muestra su cantidad de elementos.

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

1. Primera convocatoria y resultado - guión directo

Parámetros y flujo de ejecución:

• Ejecute el script C# proporcionado. El número 0, donde se pasa, denota el índice; Los paréntesis vacíos significan que no hay argumentos. El texto Print es solo un mensaje de ejemplo.
• ScriptIndex=0 selecciona la primera ejecución actual. El resultado indica su fuente; el comando no abre, guarda ni ejecuta este archivo.
• string: ruta guardada del archivo fuente o "" si no hay índice. Al ejecutar el archivo, esta suele ser la ruta completa; Es posible que el comando o la fuente no tenga un archivo normal en la memoria.
• Obligatorio ScriptIndex es un número entero, índice desde cero del nuevo GetScriptsList. Para un índice negativo o faltante, se devuelve el resultado vacío/desconocido descrito. No pase serial del elemento, el nombre del procedimiento o ID del lanzamiento desde 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. Uso en un bucle o condición: función de script

Parámetros y flujo de ejecución:

• Este es un ejemplo específico de uso compartido de comandos. La indexación de matrices comienza desde cero; Comprueba la longitud antes de manipularlo. UO.Wait(250), donde se usa, espera 250 milisegundos.
• ScriptIndex=0 selecciona la primera ejecución actual. El resultado indica su fuente; el comando no abre, guarda ni ejecuta este archivo.
• string: ruta guardada del archivo fuente o "" si no hay índice. Al ejecutar el archivo, esta suele ser la ruta completa; Es posible que el comando o la fuente no tenga un archivo normal en la memoria.
• Obligatorio ScriptIndex es un número entero, índice desde cero del nuevo GetScriptsList. Para un índice negativo o faltante, se devuelve el resultado vacío/desconocido descrito. No pase serial del elemento, el nombre del procedimiento o ID del lanzamiento desde 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. Función auxiliar completa: clase de script

Parámetros y flujo de ejecución:

• Debajo de Main está la función completa. Sus parámetros y resultados se explican por separado del comando API que llama.
• ReadScriptPath sustituye el parámetro de reserva solo si la ruta está vacía. Esta es una función separada y no una nueva sobrecarga de GetScriptPath.
• string: ruta guardada del archivo fuente o "" si no hay índice. Al ejecutar el archivo, esta suele ser la ruta completa; Es posible que el comando o la fuente no tenga un archivo normal en la memoria.
• Obligatorio ScriptIndex es un número entero, índice desde cero del nuevo GetScriptsList. Para un índice negativo o faltante, se devuelve el resultado vacío/desconocido descrito. No pase serial del elemento, el nombre del procedimiento o ID del lanzamiento desde 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;
}

Implementación del comando

C# distingue mayúsculas y minúsculas. Use el nombre UO exacto. Compare indicadores numéricos con 0; use bool solo si la firma devuelve bool.

UO.GetScriptPath(scriptIndex) — UO.GetScriptPath(Any)

Parámetros: scriptIndex (Any)

Resultado: string / String.

Durante la llamada:

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

Código interno de implementación; no es un script independiente.

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

---

UO.GetScriptState

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

Firmas de C#

int UO.GetScriptState(object? scriptIndex);

Lee el estado de ejecución por índice.

Parámetros

• scriptIndex - Obligatorio ScriptIndex - número entero, índice desde cero desde nuevo GetScriptsList. Para un índice negativo o faltante, se devuelve el resultado vacío/desconocido descrito. No pase serial del tema, el nombre del procedimiento, o ID del lanzamiento de IDE.

Valor devuelto

int - código de estado: 0 = no/desconocido, 1 = en ejecución, 2 = pausa. Esto no es un bool: compárelo explícitamente con 1 o 2.

Comportamiento

• Se tienen en cuenta los lanzamientos en ejecución y en pausa; Se excluyen aquellos completados y que hayan recibido una solicitud de cancelación. Un script en ejecución generalmente se tiene en cuenta a sí mismo. Simplemente cargar la pestaña IDE no se considera un inicio.
• Los índices son las posiciones actuales en orden de inicio. Iniciar/detener guiones puede cambiar de posición. Diferentes llamadas no forman una instantánea atómica común; Vuelva a leer la lista antes del siguiente comando de control.
• GetScriptsList da los índices, GetScriptsCount la cantidad, GetScriptState el código de tres estados. No sustituya uno por otro ni trate ningún resultado distinto de cero como el valor de true.
• Se tienen en cuenta la pausa manual/depuración y la pausa de apagado configurada. El estado 1 no garantiza que el script esté consumiendo CPU o recibiendo datos del servidor.

Scripts independientes de C#

Cada ejemplo se puede guardar como un archivo independiente .csx y ejecutar en IDE. Las funciones de objeto UO y de espera proporcionan el anfitrión de la sesión de juego actual. Reemplace los nombres, coordenadas y direcciones de la demostración serial por los suyos propios.

Ejemplo sencillo

Ejecuta este código en un archivo .csx independiente. Los argumentos aparecen en la llamada; sustituye los nombres, seriales y direcciones de ejemplo por los tuyos.

El resultado de una sola llamada se muestra en el diario. Un número no se convierte en bool; para un array se muestra su cantidad de elementos.

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

1. Primera convocatoria y resultado - guión directo

Parámetros y flujo de ejecución:

• Ejecute el script C# proporcionado. El número 0, donde se pasa, denota el índice; Los paréntesis vacíos significan que no hay argumentos. El texto Print es solo un mensaje de ejemplo.
• Se tienen en cuenta la pausa manual/depuración y la pausa de apagado configurada. El estado 1 no garantiza que el script esté consumiendo CPU o recibiendo datos del servidor.
• int - código de estado: 0 = no/desconocido, 1 = en ejecución, 2 = pausa. Esto no es un bool: compárelo explícitamente con 1 o 2.
• Obligatorio ScriptIndex es un número entero, índice desde cero del nuevo GetScriptsList. Para un índice negativo o faltante, se devuelve el resultado vacío/desconocido descrito. No pase serial del elemento, el nombre del procedimiento o ID del lanzamiento desde IDE.

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

2. Uso en un bucle o condición: función de script

Parámetros y flujo de ejecución:

• Este es un ejemplo específico de uso compartido de comandos. La indexación de matrices comienza desde cero; Comprueba la longitud antes de manipularlo. UO.Wait(250), donde se usa, espera 250 milisegundos.
• Se tienen en cuenta la pausa manual/depuración y la pausa de apagado configurada. El estado 1 no garantiza que el script esté consumiendo CPU o recibiendo datos del servidor.
• int - código de estado: 0 = no/desconocido, 1 = en ejecución, 2 = pausa. Esto no es un bool: compárelo explícitamente con 1 o 2.
• Obligatorio ScriptIndex es un número entero, índice desde cero del nuevo GetScriptsList. Para un índice negativo o faltante, se devuelve el resultado vacío/desconocido descrito. No pase serial del elemento, el nombre del procedimiento o ID del lanzamiento desde 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. Función auxiliar completa: clase de script

Parámetros y flujo de ejecución:

• Debajo de Main está la función completa. Sus parámetros y resultados se explican por separado del comando API que llama.
• IsScriptActive convierte 1 y 2 en true, y 0 en false. GetScriptState todavía devuelve un código de estado numérico.
• int - código de estado: 0 = no/desconocido, 1 = en ejecución, 2 = pausa. Esto no es un bool: compárelo explícitamente con 1 o 2.
• Obligatorio ScriptIndex es un número entero, índice desde cero del nuevo GetScriptsList. Para un índice negativo o faltante, se devuelve el resultado vacío/desconocido descrito. No pase serial del elemento, el nombre del procedimiento o ID del lanzamiento desde 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;
}

Implementación del comando

C# distingue mayúsculas y minúsculas. Use el nombre UO exacto. Compare indicadores numéricos con 0; use bool solo si la firma devuelve bool.

UO.GetScriptState(scriptIndex) — UO.GetScriptState(Any)

Parámetros: scriptIndex (Any)

Resultado: int / Integer.

Durante la llamada:

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

Código interno de implementación; no es un script independiente.

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

---

UO.GetScriptsCount

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

Firmas de C#

int UO.GetScriptsCount();

Cuenta las ejecuciones activas en este cliente.

Parámetros

No hay parámetros.

Valor devuelto

int >= 0: número de ejecuciones activas, incluidas las pausadas. Esta es una cantidad, no un bool o un índice de script.

Comportamiento

• Se tienen en cuenta los lanzamientos en ejecución y en pausa; Se excluyen aquellos completados y que hayan recibido una solicitud de cancelación. Un script en ejecución generalmente se tiene en cuenta a sí mismo. Simplemente cargar la pestaña IDE no se considera un inicio.
• Los índices son las posiciones actuales en orden de inicio. Iniciar/detener guiones puede cambiar de posición. Diferentes llamadas no forman una instantánea atómica común; Vuelva a leer la lista antes del siguiente comando de control.
• GetScriptsList da los índices, GetScriptsCount la cantidad, GetScriptState el código de tres estados. No sustituya uno por otro ni trate ningún resultado distinto de cero como el valor de true.
• No hay argumentos. El conteo no ordena la lista y no cambia el estado de las ejecuciones.

Scripts independientes de C#

Cada ejemplo se puede guardar como un archivo independiente .csx y ejecutar en IDE. Las funciones de objeto UO y de espera proporcionan el anfitrión de la sesión de juego actual. Reemplace los nombres, coordenadas y direcciones de la demostración serial por los suyos propios.

Ejemplo sencillo

Ejecuta este código en un archivo .csx independiente. Los argumentos aparecen en la llamada; sustituye los nombres, seriales y direcciones de ejemplo por los tuyos.

El resultado de una sola llamada se muestra en el diario. Un número no se convierte en bool; para un array se muestra su cantidad de elementos.

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

1. Primera convocatoria y resultado - guión directo

Parámetros y flujo de ejecución:

• Ejecute el script C# proporcionado. El número 0, donde se pasa, denota el índice; Los paréntesis vacíos significan que no hay argumentos. El texto Print es solo un mensaje de ejemplo.
• No hay argumentos. El conteo no ordena la lista y no cambia el estado de las ejecuciones.
• int >= 0: número de ejecuciones activas, incluidas las pausadas. Esta es una cantidad, no un bool o un índice de script.

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

2. Uso en un bucle o condición: función de script

Parámetros y flujo de ejecución:

• Este es un ejemplo específico de uso compartido de comandos. La indexación de matrices comienza desde cero; Comprueba la longitud antes de manipularlo. UO.Wait(250), donde se usa, espera 250 milisegundos.
• No hay argumentos. El conteo no ordena la lista y no cambia el estado de las ejecuciones.
• int >= 0: número de ejecuciones activas, incluidas las pausadas. Esta es una cantidad, no un bool o un índice de 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. Función auxiliar completa: clase de script

Parámetros y flujo de ejecución:

• Debajo de Main está la función completa. Sus parámetros y resultados se explican por separado del comando API que llama.
• HasOtherScripts compara el recuento con 1: el script de llamada normalmente ocupa una entrada. A diferencia de GetScriptsCount, la función auxiliar devuelve true/false.
• int >= 0: número de ejecuciones activas, incluidas las pausadas. Esta es una cantidad, no un bool o un índice de 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;
}

Implementación del comando

C# distingue mayúsculas y minúsculas. Use el nombre UO exacto. Compare indicadores numéricos con 0; use bool solo si la firma devuelve bool.

UO.GetScriptsCount() — UO.GetScriptsCount()

Parámetros: Sin parámetros.

Resultado: int / Integer.

Durante la llamada:

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

Código interno de implementación; no es un script independiente.

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

---

UO.GetScriptsList

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

Firmas de C#

dynamic UO.GetScriptsList();

Devuelve los índices de script numéricos actuales.

Parámetros

No hay parámetros.

Valor devuelto

Matriz de int: índices 0..N-1 o una matriz vacía. Los elementos son números, no nombres ni entradas de texto.

Comportamiento

• Se tienen en cuenta los lanzamientos en ejecución y en pausa; Se excluyen aquellos completados y que hayan recibido una solicitud de cancelación. Un script en ejecución generalmente se tiene en cuenta a sí mismo. Simplemente cargar la pestaña IDE no se considera un inicio.
• Los índices son las posiciones actuales en orden de inicio. Iniciar/detener guiones puede cambiar de posición. Diferentes llamadas no forman una instantánea atómica común; Vuelva a leer la lista antes del siguiente comando de control.
• GetScriptsList da los índices, GetScriptsCount la cantidad, GetScriptState el código de tres estados. No sustituya uno por otro ni trate ningún resultado distinto de cero como el valor de true.
• No hay argumentos. Pase cada número al captador correspondiente del nombre, ruta o estado. La matriz resultante es una instantánea separada; cambiarlo no controla los scripts.

Scripts independientes de C#

Cada ejemplo se puede guardar como un archivo independiente .csx y ejecutar en IDE. Las funciones de objeto UO y de espera proporcionan el anfitrión de la sesión de juego actual. Reemplace los nombres, coordenadas y direcciones de la demostración serial por los suyos propios.

Ejemplo sencillo

Ejecuta este código en un archivo .csx independiente. Los argumentos aparecen en la llamada; sustituye los nombres, seriales y direcciones de ejemplo por los tuyos.

El resultado de una sola llamada se muestra en el diario. Un número no se convierte en bool; para un array se muestra su cantidad de elementos.

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

1. Primera convocatoria y resultado - guión directo

Parámetros y flujo de ejecución:

• Ejecute el script C# proporcionado. El número 0, donde se pasa, denota el índice; Los paréntesis vacíos significan que no hay argumentos. El texto Print es solo un mensaje de ejemplo.
• No hay argumentos. Pase cada número al captador correspondiente del nombre, ruta o estado. La matriz resultante es una instantánea separada; cambiarlo no controla los scripts.
• Matriz de int: índices 0..N-1 o una matriz vacía. Los elementos son números, no nombres ni entradas de texto.

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

2. Uso en un bucle o condición: función de script

Parámetros y flujo de ejecución:

• Este es un ejemplo específico de uso compartido de comandos. La indexación de matrices comienza desde cero; Comprueba la longitud antes de manipularlo. UO.Wait(250), donde se usa, espera 250 milisegundos.
• No hay argumentos. Pase cada número al captador correspondiente del nombre, ruta o estado. La matriz resultante es una instantánea separada; cambiarlo no controla los scripts.
• Matriz de int: índices 0..N-1 o una matriz vacía. Los elementos son números, no nombres ni entradas de texto.

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. Función auxiliar completa: clase de script

Parámetros y flujo de ejecución:

• Debajo de Main está la función completa. Sus parámetros y resultados se explican por separado del comando API que llama.
• FindNamedScript itera a través de los índices actuales y devuelve la primera coincidencia exacta del nombre para mostrar o -1. Los nombres pueden repetirse y los índices pueden moverse más tarde.
• Matriz de int: índices 0..N-1 o una matriz vacía. Los elementos son números, no nombres ni entradas de texto.

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;
}

Implementación del comando

C# distingue mayúsculas y minúsculas. Use el nombre UO exacto. Compare indicadores numéricos con 0; use bool solo si la firma devuelve bool.

UO.GetScriptsList() — UO.GetScriptsList()

Parámetros: Sin parámetros.

Resultado: dynamic / Array.

Durante la llamada:

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

Código interno de implementación; no es un script independiente.

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

---

UO.Launch

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

Firmas de 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);

Parámetros

• file — Ruta/nombre obligatorio del programa o documento; convertido a texto, se eliminan los espacios exteriores. Un valor vacío da 0 y un mensaje de error. Para seleccionar el programa exacto, utilice la ruta completa; No es necesario agregar comillas externas al archivo.
• workingDirectory — Carpeta de trabajo opcional del proceso. Si hay una omisión o una línea vacía, se toma la carpeta del script actual. Si el tiempo de ejecución no tiene dicha carpeta, bridge usa la carpeta de trabajo actual del cliente. Esta no siempre es la carpeta del juego o la carpeta del cliente EXE.
• hidden: valor booleano opcional, predeterminado false. true desactiva la apertura a través del shell del sistema operativo y solicita el inicio sin una ventana de consola; necesitas un archivo ejecutable. false permite asociaciones de documentos. El programa GUI todavía puede mostrar su ventana.

Valor devuelto

int: 1 (true) si Process.Start devolvió un objeto de proceso; en caso contrario 0 (false). En C# verifique resultado == 1 o resultado!= 0; int no se puede comparar directamente con true. Esto no es PID, un código de salida ni una confirmación de finalización del trabajo. Si se produce una excepción, se genera un error y se devuelve 0. Al abrir un documento a través de un programa que ya se está ejecutando, el sistema operativo a veces no devuelve un nuevo proceso: 0 en este caso no prueba que el documento no se abrió.

Comportamiento

• Sólo se permiten sobrecargas de uno a cuatro argumentos, en el orden especificado. Para especificar oculto y dejar la carpeta de trabajo predeterminada, pase una cadena vacía como tercer argumento. Las conversiones de archivo/parámetros/workingDirectory a texto no verifican la existencia del archivo de antemano.
• La carpeta predeterminada está determinada por el script que se está ejecutando actualmente. Con oculto=true la ruta relativa del programa se compara primero con workingDirectory. La búsqueda parcial de nombres de sistema operativo y las asociaciones son específicas del sistema; la ruta completa elimina la ambigüedad. Si la carpeta o el programa de trabajo no está disponible, es posible que el inicio falle.
• El proceso externo se ejecuta de forma independiente. Launch no espera a que se complete, no lee stdout/stderr y no lo finaliza cuando se detiene el script. true para oculto es una solicitud de un método de inicio y no una garantía de la invisibilidad de ninguna ventana. El objeto Proceso se libera después de la solicitud; el programa en ejecución continúa ejecutándose.

Scripts independientes de C#

Cada ejemplo se puede guardar como un archivo independiente .csx y ejecutar en IDE. Las funciones de objeto UO y de espera proporcionan el anfitrión de la sesión de juego actual. Reemplace los nombres, coordenadas y direcciones de la demostración serial por los suyos propios.

Ejemplo sencillo

Ejecuta este código en un archivo .csx independiente. Los argumentos aparecen en la llamada; sustituye los nombres, seriales y direcciones de ejemplo por los tuyos.

El resultado de una sola llamada se muestra en el diario. Un número no se convierte en bool; para un array se muestra su cantidad de elementos.

var result = UO.Launch("loot-report.txt");
UO.Print("Launch: " + Convert.ToString(result));

1. Abra un informe de minería listo para usar: guión directo

Parámetros y flujo de ejecución:

• Coloque el botín-report.txt existente junto al script. El sistema operativo lo abre con la aplicación asignada al .txt. Main devuelve el resultado de la solicitud Launch, no el contenido del informe ni la confirmación de que se leyó.

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

2. Pasar ruta con espacios al editor - función de script

Parámetros y flujo de ejecución:

• La carpeta y el informe deben existir; reemplázalos por los tuyos propios. Chr(34) incluye la ruta completa del informe entre comillas dobles dentro de los argumentos. notepad.exe debe ser accesible para el sistema. false habilita la ventana del editor normal.

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. Prepare una lista de registros locales sin una ventana de consola: clase de script

Parámetros y flujo de ejecución:

• El ejemplo de Windows ejecuta el cmd.exe integrado. En la carpeta del script, se crea o se sobrescribe log-files.txt con una lista de *.logs. Un tercer argumento vacío guarda la carpeta del script, true oculta la consola. true desde Principal significa solo iniciar: es posible que el archivo aún no esté listo y la ausencia de *.log o un error de utilidad no cambia el resultado ya obtenido 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;
}

Implementación del comando

C# distingue mayúsculas y minúsculas. Use el nombre UO exacto. Compare indicadores numéricos con 0; use bool solo si la firma devuelve bool.

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

Parámetros: file (Any)

Resultado: int / Integer.

Durante la llamada:

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

La llamada ejecuta el delegate del controlador guardado. El método de registro crea ese delegate al construir la API.

Código interno de implementación; no es un script independiente.

values => new InjectionValue(CompactLaunch(values))

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

Parámetros: file (Any), parameters (Any)

Resultado: int / Integer.

Durante la llamada:

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

La llamada ejecuta el delegate del controlador guardado. El método de registro crea ese delegate al construir la API.

Código interno de implementación; no es un script independiente.

values => new InjectionValue(CompactLaunch(values))

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

Parámetros: file (Any), parameters (Any), workingDirectory (Any)

Resultado: int / Integer.

Durante la llamada:

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

La llamada ejecuta el delegate del controlador guardado. El método de registro crea ese delegate al construir la API.

Código interno de implementación; no es un script independiente.

values => new InjectionValue(CompactLaunch(values))

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

Parámetros: file (Any), parameters (Any), workingDirectory (Any), hidden (Any)

Resultado: int / Integer.

Durante la llamada:

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

La llamada ejecuta el delegate del controlador guardado. El método de registro crea ese delegate al construir la API.

Código interno de implementación; no es un script independiente.

values => new InjectionValue(CompactLaunch(values))

---

UO.PauseResumeScript

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

Firmas de C#

void UO.PauseResumeScript(object? scriptIndex);

Alterna la pausa manual de una ejecución activa. Úselo para detener temporalmente la minería u otro procedimiento sin perder su progreso actual.

Parámetros

• scriptIndex - Obligatorio ScriptIndex - índice de lanzamiento actual: 0 significa el primero, luego 1, 2... Consíguelo a través de GetScriptsList; no es serial, el nombre del archivo y no el resultado StartScript. Un índice negativo/faltante no cambia nada.

Valor devuelto

void: sin valor de retorno. No compares la llamada con true/1. Verifique la condición leyendo por separado GetScriptState; el resultado de dicha lectura es 0 (sin inicio), 1 (en funcionamiento), 2 (pausa).

Comportamiento

• Funciona sólo con ejecuciones de la sesión actual. Una pestaña abierta sin ejecución no es un inicio activo. La detención no elimina el archivo original ni desconecta la conexión al servidor.
• Los índices son dinámicos: las posiciones pueden moverse después de que se completa otra ejecución. Múltiples llamadas API no son una operación atómica. Los ejemplos están diseñados para la ausencia de cambios paralelos en la lista; busque la ejecución deseada nuevamente antes de la acción y no almacene el índice a través de UO.Wait.
• Este es un cambio, no un comando de "continuar siempre". Las pausas manuales y automáticas son independientes: cambiar a manual no elimina la pausa por interrupción de la conexión. El código 2 no explica el motivo de la pausa. Si detiene su propio lanzamiento de esta manera, no podrá realizar la siguiente llamada para continuarlo; reanudar desde IDE/manager u otro script.

Scripts independientes de C#

Cada ejemplo se puede guardar como un archivo independiente .csx y ejecutar en IDE. Las funciones de objeto UO y de espera proporcionan el anfitrión de la sesión de juego actual. Reemplace los nombres, coordenadas y direcciones de la demostración serial por los suyos propios.

Ejemplo sencillo

Ejecuta este código en un archivo .csx independiente. Los argumentos aparecen en la llamada; sustituye los nombres, seriales y direcciones de ejemplo por los tuyos.

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

1. Alternar pausa por nombre - guión directo

Parámetros y flujo de ejecución:

• MineOre es un ejemplo del nombre para mostrar de un procedimiento que ya se está ejecutando. FindNamedRun devuelve el primer índice coincidente o -1. Llamada desde otro controlador; llamar nuevamente cambia la pausa manual.
• Los índices son dinámicos: las posiciones pueden moverse después de que se completa otra ejecución. Múltiples llamadas API no son una operación atómica. Los ejemplos están diseñados para la ausencia de cambios paralelos en la lista; busque la ejecución deseada nuevamente antes de la acción y no almacene el índice a través de 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. Pausar un inicio en ejecución: función de script

Parámetros y flujo de ejecución:

• Verificar == 1 limita la acción a un disparador en ejecución. El valor 2 no se utiliza como indicación de "pausa manual clara" porque puede indicar que no hay comunicación.
• Los índices son dinámicos: las posiciones pueden moverse después de que se completa otra ejecución. Múltiples llamadas API no son una operación atómica. Los ejemplos están diseñados para la ausencia de cambios paralelos en la lista; busque la ejecución deseada nuevamente antes de la acción y no almacene el índice a través de 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. Seleccione ejecutar por archivo - clase de script

Parámetros y flujo de ejecución:

• Reemplaza la ruta absoluta por la tuya. FindFileRun compara rutas sin distinguir entre mayúsculas y minúsculas y devuelve la primera ejecución de este archivo; Se pueden ejecutar varios procedimientos en un solo archivo.
• Los índices son dinámicos: las posiciones pueden moverse después de que se completa otra ejecución. Múltiples llamadas API no son una operación atómica. Los ejemplos están diseñados para la ausencia de cambios paralelos en la lista; busque la ejecución deseada nuevamente antes de la acción y no almacene el índice a través de 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) ?? "");
}

Implementación del comando

C# distingue mayúsculas y minúsculas. Use el nombre UO exacto. Compare indicadores numéricos con 0; use bool solo si la firma devuelve bool.

UO.PauseResumeScript(scriptIndex) — UO.PauseResumeScript(Any)

Parámetros: scriptIndex (Any)

Resultado: void / Unit.

Durante la llamada:

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

Código interno de implementación; no es un script independiente.

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

---

UO.SetEvent

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

Firmas de 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);

Activa o desactiva el seguimiento de los cambios en el estado del personaje y te permite seleccionar una reacción única o repetida. Por ejemplo, puedes cancelar el objetivo restante una vez después de la muerte o recibir advertencias sobre baja resistencia. El controlador se especifica por separado de la condición; el script principal debería continuar ejecutándose UO.Wait.

Parámetros

• name: una cadena con uno de cinco nombres: ChangeHitPoints, ChangeMana, ChangeStamina, Muerte, SeeNewPlayer. El caso no es importante; el prefijo ev es aceptable, por ejemplo evChangeMana. Se eliminan los espacios en blanco alrededor de los bordes. No existe un catálogo numérico de eventos; un nombre arbitrario no crea un nuevo evento.
• nameValue — Mismo nombre de evento que el nombre; este es el nombre del primer parámetro en formato de cuatro argumentos, no un valor opcional.
• stateValue - true/1 activa la vigilancia, false/0 se da de baja. Pase valores booleanos sin comillas. En una conversión numérica, cualquier número entero distinto de cero incluye una observación. La desactivación no espera ni detiene un controlador que ya se está ejecutando.
• repeatOrHandler — El tercer argumento tiene dos propósitos. Una cadena no numérica y no vacía, como "OnManaChanged", especifica un controlador de repetición automática. Número/bool conjuntos se repiten únicamente: false/0 — una operación, true/1 — repetición; no se asigna ningún controlador en este formulario. La cadena "1" también es numérica y no es un nombre de procedimiento. Para un controlador único, utilice cuatro argumentos.
• repeatValue - En el formulario con cuatro argumentos: false/0 - elimina la suscripción después de la primera transición detectada, true/1 - déjala para los próximos cambios. Una suscripción única también se cancela cuando no se encuentra el controlador o el administrador rechaza su lanzamiento; No confunda la detección de un evento con la finalización exitosa de un procedimiento.

Valor devuelto

void - sin valor. Llame en una línea separada, sin resultado var = y sin comparación con true/1. Completar el registro no confirma que se haya encontrado, iniciado o que el servidor haya realizado alguna acción. Si el nombre del procedimiento no se encuentra en el evento, la llamada no se produce.

Comportamiento

• Dos argumentos: false desactiva el evento; true implica observación repetida sin un guía. Cualquier procedimiento con un nombre coincidente no se sustituye automáticamente. Este formulario no arroja ningún resultado y no reemplaza la prueba HP/Mana/Dead.
• Los cuatro argumentos especifican explícitamente el nombre del evento, la habilitación, la repetición y el controlador. Ambos parámetros booleanos se escriben sin comillas. false/0 = one-shot: la suscripción se cancela después de la primera transición detectada, no después del final del controlador.
• El nuevo registro de un evento reemplaza su configuración anterior y recuerda el estado actual como un nuevo punto de referencia. Las suscripciones SetEvent y SetEventProc a un nombre normalizado dentro de un script utilizan un registro y no se acumulan.
• ChangeHitPoints compara el HP self actual con la instantánea anterior; desencadena tanto al perder como al recuperar la salud. ChangeMana y ChangeStamina reaccionan de manera similar en ambas direcciones. No se trata sólo de daño, consumo de maná o fatiga.
• La muerte se activa cuando se hace la transición vivo → muerto. Registrar un personaje ya muerto no llama inmediatamente al controlador; morir de nuevo después de la resurrección puede desencadenarlo nuevamente.
• SeeNewPlayer compara el conjunto de móviles descargados excluyendo 0 y self. El nombre no significa probar al jugador real: esto incluye a NPC y las criaturas. Uno o más serial nuevos por verificación provocan un intento de inicio. El regreso del mobile fallecido del conjunto cargado también puede considerarse una nueva aparición. ID no se pasa al controlador; los objetos necesarios deben encontrarse por separado.
• UO.Wait y WaitAsync dividen la espera en intervalos de hasta 25 ms y verifican si hay eventos después de cada uno; UO.Wait(0) también realiza la verificación. Se trata de sondear el estado disponible en lugar de interceptar cada paquete de red: es posible que se pierdan los cambios rápidos y las devoluciones entre comprobaciones. No hay un monitoreo constante en un ciclo de cálculo sin UO.Wait o después de que se haya completado el script principal.
• El nombre del controlador está preasociado con el delegado C# a través de RegisterRoutine. La devolución de llamada se ejecuta de forma asincrónica en esta sesión; una tarea no se superpone a sí misma. Una vez finalizado el guión principal, sus acciones adicionales están prohibidas.
• Una suscripción hace referencia a una instancia de un script en ejecución. Elimínelo en Main, que lo creó: el comando del mismo nombre dentro de un controlador iniciado por separado cambiará sus propias suscripciones. Dar de baja el registro no detiene un controlador que ya se está ejecutando. Utilice try/finally para una salida normal o un error manejable; Force Stop también detiene más sondeos de este script.
• Un nombre de evento desconocido que no esté vacío se rechaza con un mensaje del sistema al registrarse. Un nombre vacío no hace nada. La presencia de un controlador se comprueba sólo cuando se activa; Es mejor detectar un error en su nombre de antemano a través de SubExists y verificar el script en IDE.

En C# el controlador debe estar registrado explícitamente: RegisterRoutine("Handler", Handler). Los cambios en HP, maná y resistencia llegan a través de la cola de eventos nativa; Muerte y SeeNewPlayer se comparan con instantáneas del mundo local. Las suscripciones directas con argumentos están disponibles a través de SubscribeEvent("UO.JournalEntry", controlador) y nombres nativos similares. Todas las suscripciones se liberan cuando se completa o cancela esta ejecución.

Archivos C# cargados

Además de los delegados locales, el administrador actual admite entradas C# cargadas explícitamente con una clave como Child.csx::Main. SubExists y FunRunning aceptan dicha clave; CallSub ejecuta el archivo sin Args y Exec("exec Child.csx::Main 'north gate' 42") pasa Args. La clave con espacios está entre comillas dentro de Exec. Se acepta un nombre corto único, un nombre ambiguo no selecciona un archivo aleatorio. El registro local tiene prioridad. El lanzamiento de un archivo obtiene su propio contexto y duración en el mundo/administrador actual; Los delegados locales pertenecen a la ejecución que los registró.

Scripts independientes de C#

Cada ejemplo se puede guardar como un archivo independiente .csx y ejecutar en IDE. Las funciones de objeto UO y de espera proporcionan el anfitrión de la sesión de juego actual. Reemplace los nombres, coordenadas y direcciones de la demostración serial por los suyos propios.

Ejemplo sencillo

Ejecuta este código en un archivo .csx independiente. Los argumentos aparecen en la llamada; sustituye los nombres, seriales y direcciones de ejemplo por los tuyos.

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

1. Cancelar un objetivo incompleto una vez después de la muerte - guión directo

Parámetros y flujo de ejecución:

• La observación dura ocho segundos. La muerte de un personaje ya muerto no llama al cuidador inmediatamente. En este ejemplo ya no se procesa el segundo evento de muerte después de la resurrección.
• El controlador verifica el cursor activo del objetivo en el momento de la ejecución y solo entonces llama a CancelTarget. En este ejemplo, una cola preparada sin un cursor activo no se cancela. El guión no resucita al personaje, no detiene todos los guiones y no finaliza Main. No ejecute el ejemplo si desea mantener el objetivo activo.

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. Advertencia de resistencia repetida: formato breve: función de secuencia de comandos

Parámetros y flujo de ejecución:

• 24 × 250 ms – seis segundos. 10 es nuestro umbral en el controlador, no el argumento adicional SetEvent. El aumento de resistencia también lo provoca el manejador, pero con un valor de 10 no se muestra el mensaje.
• true, "OnFatigue" es diferente de true, true: esta última opción especifica la repetición sin procedimiento. El script no aumenta la resistencia ni cambia la velocidad del servidor.

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. Alternar controlador de maná sin acumular suscripciones - clase de script

Parámetros y flujo de ejecución:

• Durante los primeros dos segundos, cada cambio detectado activa OnManaLog. Durante los siguientes tres segundos, se utiliza OnLowMana. El registro de un segundo controlador no lo activa.
• La sustitución no interrumpe el antiguo procedimiento que ya está en marcha. Estos controladores cortos no utilizan variables locales principales. Si se prohíbe la imposición de procedimientos, el administrador puede rechazar el lanzamiento; para este modo, verifique Mana directamente en Principal.

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);
}

Implementación del comando

C# distingue mayúsculas y minúsculas. Use el nombre UO exacto. Compare indicadores numéricos con 0; use bool solo si la firma devuelve bool.

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

Parámetros: name (Any), stateValue (Any)

Resultado: void / Unit.

Durante la llamada:

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

Código interno de implementación; no es un script independiente.

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

Código interno de implementación; no es un script independiente.

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)

Parámetros: name (Any), stateValue (Any), repeatOrHandler (Any)

Resultado: void / Unit.

Durante la llamada:

• 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).

Código interno de implementación; no es un script independiente.

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

Código interno de implementación; no es un script independiente.

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)

Parámetros: nameValue (Any), stateValue (Any), repeatValue (Any), subNameValue (Any)

Resultado: void / Unit.

Durante la llamada:

• 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).

Código interno de implementación; no es un script independiente.

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

Código interno de implementación; no es un script independiente.

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 · 繁體中文 · 日本語 · 한국어

Firmas de C#

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

Designa un procedimiento que el cliente ejecutará cuando cambie un estado observado: por ejemplo, cuando se pierde salud, cambia maná o aparece un nuevo mobile. Le permite separar la reacción del ciclo principal. El registro en sí no ejecuta nada: el script principal debe permanecer activo; C#: puntos de control, WaitAsync y UO.Wait manejan eventos.

Parámetros

• eventname: una cadena con uno de cinco nombres: ChangeHitPoints, ChangeMana, ChangeStamina, Muerte, SeeNewPlayer. El caso no es importante; el prefijo ev es aceptable, por ejemplo evChangeMana. Se eliminan los espacios en blanco alrededor de los bordes. No existe un catálogo numérico de eventos; un nombre arbitrario no crea un nuevo evento.

Valor devuelto

void - sin valor. Llame en una línea separada, sin resultado var = y sin comparación con true/1. Completar el registro no confirma que se haya encontrado, iniciado o que el servidor haya realizado alguna acción. Si el nombre del procedimiento no se encuentra en el evento, la llamada no se produce.

Comportamiento

• Ambos argumentos son necesarios. La suscripción es recurrente: los nuevos cambios detectados provocan nuevos intentos de lanzamiento. En un script en ejecución, se asigna un controlador a un nombre de evento normalizado; el nuevo registro lo reemplaza y actualiza la instantánea inicial. SetEventProc(evento, "") se da de baja en el mismo script. Para una reacción única, utilice SetEvent(evento, true, false, "Handler").
• ChangeHitPoints compara el HP self actual con la instantánea anterior; desencadena tanto al perder como al recuperar la salud. ChangeMana y ChangeStamina reaccionan de manera similar en ambas direcciones. No se trata sólo de daño, consumo de maná o fatiga.
• La muerte se activa cuando se hace la transición vivo → muerto. Registrar un personaje ya muerto no llama inmediatamente al controlador; morir de nuevo después de la resurrección puede desencadenarlo nuevamente.
• SeeNewPlayer compara el conjunto de móviles descargados excluyendo 0 y self. El nombre no significa probar al jugador real: esto incluye a NPC y las criaturas. Uno o más serial nuevos por verificación provocan un intento de inicio. El regreso del mobile fallecido del conjunto cargado también puede considerarse una nueva aparición. ID no se pasa al controlador; los objetos necesarios deben encontrarse por separado.
• UO.Wait y WaitAsync dividen la espera en intervalos de hasta 25 ms y verifican si hay eventos después de cada uno; UO.Wait(0) también realiza la verificación. Se trata de sondear el estado disponible en lugar de interceptar cada paquete de red: es posible que se pierdan los cambios rápidos y las devoluciones entre comprobaciones. No hay un monitoreo constante en un ciclo de cálculo sin UO.Wait o después de que se haya completado el script principal.
• El nombre del controlador está preasociado con el delegado C# a través de RegisterRoutine. La devolución de llamada se ejecuta de forma asincrónica en esta sesión; una tarea no se superpone a sí misma. Una vez finalizado el guión principal, sus acciones adicionales están prohibidas.
• Una suscripción hace referencia a una instancia de un script en ejecución. Elimínelo en Main, que lo creó: el comando del mismo nombre dentro de un controlador iniciado por separado cambiará sus propias suscripciones. Dar de baja el registro no detiene un controlador que ya se está ejecutando. Utilice try/finally para una salida normal o un error manejable; Force Stop también detiene más sondeos de este script.
• Un nombre de evento desconocido que no esté vacío se rechaza con un mensaje del sistema al registrarse. Un nombre vacío no hace nada. La presencia de un controlador se comprueba sólo cuando se activa; Es mejor detectar un error en su nombre de antemano a través de SubExists y verificar el script en IDE.

En C# el controlador debe estar registrado explícitamente: RegisterRoutine("Handler", Handler). Los cambios en HP, maná y resistencia llegan a través de la cola de eventos nativa; Muerte y SeeNewPlayer se comparan con instantáneas del mundo local. Las suscripciones directas con argumentos están disponibles a través de SubscribeEvent("UO.JournalEntry", controlador) y nombres nativos similares. Todas las suscripciones se liberan cuando se completa o cancela esta ejecución.

Archivos C# cargados

Además de los delegados locales, el administrador actual admite entradas C# cargadas explícitamente con una clave como Child.csx::Main. SubExists y FunRunning aceptan dicha clave; CallSub ejecuta el archivo sin Args y Exec("exec Child.csx::Main 'north gate' 42") pasa Args. La clave con espacios está entre comillas dentro de Exec. Se acepta un nombre corto único, un nombre ambiguo no selecciona un archivo aleatorio. El registro local tiene prioridad. El lanzamiento de un archivo obtiene su propio contexto y duración en el mundo/administrador actual; Los delegados locales pertenecen a la ejecución que los registró.

Scripts independientes de C#

Cada ejemplo se puede guardar como un archivo independiente .csx y ejecutar en IDE. Las funciones de objeto UO y de espera proporcionan el anfitrión de la sesión de juego actual. Reemplace los nombres, coordenadas y direcciones de la demostración serial por los suyos propios.

Ejemplo sencillo

Ejecuta este código en un archivo .csx independiente. Los argumentos aparecen en la llamada; sustituye los nombres, seriales y direcciones de ejemplo por los tuyos.

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

1. Supervise los cambios de estado durante 10 segundos: secuencia de comandos directa

Parámetros y flujo de ejecución:

• ChangeHitPoints observa HP de su personaje. OnHealthChanged: nombre del método debajo/arriba de Principal en el mismo archivo cargado. UO.Wait maneja eventos; un segundo argumento vacío desactiva la repetición.
• El cuidador sólo avisa y no selecciona automáticamente el tratamiento. Al cambiar HP 60 → 50 → 70 se realizan dos reacciones; Este no es un contador de visitas.

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. Monitorear el maná y la resistencia durante la preparación es una función del script.

Parámetros y flujo de ejecución:

• evChangeMana y ChangeMana son un evento. Hay dos suscripciones independientes y dos manejadores diferentes, no dos manejadores con el mismo nombre. Los umbrales 20 y 10 se pueden cambiar.
• La espera dura 5 segundos. También se detecta la recuperación de recursos, pero no emite una advertencia cuando el valor ya está por encima del umbral.

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. Observe nuevos móviles, luego deshabilite el monitoreo - clase de script

Parámetros y flujo de ejecución:

• SeeNewPlayer detecta la aparición de serial en el conjunto de móviles cargados, incluido NPC. Cargar cinco criaturas a la vez no garantiza cinco invocaciones.
• GetMobiles(): lectura separada del conjunto real, no ID del evento. Seleccionar un enemigo requiere condiciones explícitas; el ejemplo no ataca intencionalmente a nadie.

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);
}

Implementación del comando

C# distingue mayúsculas y minúsculas. Use el nombre UO exacto. Compare indicadores numéricos con 0; use bool solo si la firma devuelve bool.

UO.SetEventProc(eventname, procname) — UO.SetEventProc(Any,Any)

Parámetros: eventname (Any), procname (Any)

Resultado: void / Unit.

Durante la llamada:

• 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]).

Código interno de implementación; no es un script independiente.

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

Código interno de implementación; no es un script independiente.

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 · 繁體中文 · 日本語 · 한국어

Firmas de C#

void UO.SetPauseScriptOnDisconnectStatus(object? value);

Cambia la regla para que los scripts se detengan cuando se pierde la conexión.

Parámetros

• value - 0 se apaga; cualquier número entero distinto de cero incluye.

Valor devuelto

void - sin valor. Llame en una línea separada; la finalización no confirma la acción del servidor.

Comportamiento

• SetPauseScriptOnDisconnectStatus establece _manager.PauseScriptsOnDisconnect = habilitado!= 0. Los scripts que ya se están ejecutando no reciben el comando PauseResumeScript aquí.
• Cambia la configuración del cliente. El valor no es el resultado de una prueba de conexión y no confirma el procesamiento por parte del servidor.

Scripts independientes de C#

Cada ejemplo se puede guardar como un archivo independiente .csx y ejecutar en IDE. Las funciones de objeto UO y de espera proporcionan el anfitrión de la sesión de juego actual. Reemplace los nombres, coordenadas y direcciones de la demostración serial por los suyos propios.

Ejemplo sencillo

Ejecuta este código en un archivo .csx independiente. Los argumentos aparecen en la llamada; sustituye los nombres, seriales y direcciones de ejemplo por los tuyos.

El comando es una instrucción independiente. El mensaje anterior indica el inicio de la llamada y no confirma una acción del servidor.

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

1. Llamada directa - guión directo

Parámetros y flujo de ejecución:

• Cambia la regla para que los scripts se detengan cuando se pierde la conexión.

UO.SetPauseScriptOnDisconnectStatus(1);

2. Opción explícita: función de script

Parámetros y flujo de ejecución:

• SetPauseScriptOnDisconnectStatus establece _manager.PauseScriptsOnDisconnect = habilitado!= 0. Los scripts que ya se están ejecutando no reciben el comando PauseResumeScript aquí.

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

3. Función auxiliar completa: clase de script

Parámetros y flujo de ejecución:

• Cambia la configuración del cliente. El valor no es el resultado de una prueba de conexión y no confirma el procesamiento por parte del servidor.

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);
    }
}

Implementación del comando

C# distingue mayúsculas y minúsculas. Use el nombre UO exacto. Compare indicadores numéricos con 0; use bool solo si la firma devuelve bool.

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

Parámetros: value (Any)

Resultado: void / Unit.

Durante la llamada:

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

Código interno de implementación; no es un script independiente.

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

---

UO.SetScriptName

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

Firmas de C#

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

Cambia el nombre para mostrar de una ejecución activa. Ayuda a distinguir entre tareas en ejecución en la lista y a través de GetScriptName.

Parámetros

• scriptIndex - Obligatorio ScriptIndex - índice de lanzamiento actual: 0 significa el primero, luego 1, 2... Consíguelo a través de GetScriptsList; no es serial, el nombre del archivo y no el resultado StartScript. Un índice negativo/faltante no cambia nada.
• value - Valor requerido - nuevo nombre, convertido en una cadena. Se permiten espacios; también es aceptable una cadena vacía. Esta es la firma de la ejecución actual y no el nuevo nombre del archivo o procedimiento en el origen.

Valor devuelto

void: sin valor de retorno. No compares la llamada con true/1. Verifique la condición leyendo por separado GetScriptState; el resultado de dicha lectura es 0 (sin inicio), 1 (en funcionamiento), 2 (pausa).

Comportamiento

• Funciona sólo con ejecuciones de la sesión actual. Una pestaña abierta sin ejecución no es un inicio activo. La detención no elimina el archivo original ni desconecta la conexión al servidor.
• Los índices son dinámicos: las posiciones pueden moverse después de que se completa otra ejecución. Múltiples llamadas API no son una operación atómica. Los ejemplos están diseñados para la ausencia de cambios paralelos en la lista; busque la ejecución deseada nuevamente antes de la acción y no almacene el índice a través de UO.Wait.

Scripts independientes de C#

Cada ejemplo se puede guardar como un archivo independiente .csx y ejecutar en IDE. Las funciones de objeto UO y de espera proporcionan el anfitrión de la sesión de juego actual. Reemplace los nombres, coordenadas y direcciones de la demostración serial por los suyos propios.

Ejemplo sencillo

Ejecuta este código en un archivo .csx independiente. Los argumentos aparecen en la llamada; sustituye los nombres, seriales y direcciones de ejemplo por los tuyos.

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

1. Dale a la tarea un nombre claro: guión directo

Parámetros y flujo de ejecución:

• MineOre se busca en ejecuciones activas, Minería es la nueva firma. Los nombres entre comillas son creados por el usuario y se pueden reemplazar.
• Los índices son dinámicos: las posiciones pueden moverse después de que se completa otra ejecución. Múltiples llamadas API no son una operación atómica. Los ejemplos están diseñados para la ausencia de cambios paralelos en la lista; busque la ejecución deseada nuevamente antes de la acción y no almacene el índice a través de 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. Distinguir entre tareas de diferentes archivos: función de script

Parámetros y flujo de ejecución:

• Reemplace wantedPath con su ruta absoluta. La firma del primer inicio activo de este archivo cambia, pero el archivo en el disco permanece en el mismo lugar.
• Los índices son dinámicos: las posiciones pueden moverse después de que se completa otra ejecución. Múltiples llamadas API no son una operación atómica. Los ejemplos están diseñados para la ausencia de cambios paralelos en la lista; busque la ejecución deseada nuevamente antes de la acción y no almacene el índice a través de 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. Agregar estado a la firma: clase de secuencia de comandos

Parámetros y flujo de ejecución:

• GetScriptState = 2 agrega el texto pausado al nombre. Esta es una firma única: no se actualiza automáticamente después de continuar y no controla la pausa en sí.
• Los índices son dinámicos: las posiciones pueden moverse después de que se completa otra ejecución. Múltiples llamadas API no son una operación atómica. Los ejemplos están diseñados para la ausencia de cambios paralelos en la lista; busque la ejecución deseada nuevamente antes de la acción y no almacene el índice a través de 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;
}

Implementación del comando

C# distingue mayúsculas y minúsculas. Use el nombre UO exacto. Compare indicadores numéricos con 0; use bool solo si la firma devuelve bool.

UO.SetScriptName(scriptIndex, value) — UO.SetScriptName(Any,Any)

Parámetros: scriptIndex (Any), value (Any)

Resultado: void / Unit.

Durante la llamada:

• 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).

Código interno de implementación; no es un script independiente.

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

---

UO.StartScript

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

Firmas de C#

int UO.StartScript(object? scriptPath);

Parámetros

Valor devuelto

int: número de ejecuciones activas desde la ejecución aceptada; 65535 (0xFFFF) = error de inicio. Este no es el índice del nuevo script, ni es un bool, ni es el resultado de su finalización.

Comportamiento

• Se tienen en cuenta los lanzamientos en ejecución y en pausa; Se excluyen aquellos completados y que hayan recibido una solicitud de cancelación. Un script en ejecución generalmente se tiene en cuenta a sí mismo. Simplemente cargar la pestaña IDE no se considera un inicio.
• Los índices son las posiciones actuales en orden de inicio. Iniciar/detener guiones puede cambiar de posición. Diferentes llamadas no forman una instantánea atómica común; Vuelva a leer la lista antes del siguiente comando de control.
• GetScriptsList da los índices, GetScriptsCount la cantidad, GetScriptState el código de tres estados. No sustituya uno por otro ni trate ningún resultado distinto de cero como el valor de true.

Scripts independientes de C#

Cada ejemplo se puede guardar como un archivo independiente .csx y ejecutar en IDE. Las funciones de objeto UO y de espera proporcionan el anfitrión de la sesión de juego actual. Reemplace los nombres, coordenadas y direcciones de la demostración serial por los suyos propios.

Ejemplo sencillo

Ejecuta este código en un archivo .csx independiente. Los argumentos aparecen en la llamada; sustituye los nombres, seriales y direcciones de ejemplo por los tuyos.

El resultado de una sola llamada se muestra en el diario. Un número no se convierte en bool; para un array se muestra su cantidad de elementos.

var result = UO.StartScript("Scripts/Worker.csx");
UO.Print("StartScript: " + Convert.ToString(result));

1. Primera convocatoria y resultado - guión directo

Parámetros y flujo de ejecución:

• Ejecute el script C# proporcionado. El número 0, donde se pasa, denota el índice; Los paréntesis vacíos significan que no hay argumentos. El texto Print es solo un mensaje de ejemplo.
• Antes de los ejemplos, cree por separado los archivos Worker.csx especificados. Una ruta no válida/inaccesible, una ruta principal inapropiada, un C# deshabilitado o una ejecución paralela deshabilitada resultarán en una falla. Si la ejecución anterior aún está detenida, es posible realizar un reintento retrasado; aceptar el inicio no significa completarlo. Es posible que finalice un breve guión antes de leer la cantidad devuelta.
• int: número de ejecuciones activas desde la ejecución aceptada; 65535 (0xFFFF) = error de inicio. Este no es el índice del nuevo script, ni es un bool, ni es el resultado de su finalización.
• Obligatorio ScriptPath es una cadena. La ruta relativa comienza en la carpeta AutoLoad de este cliente; El camino absoluto es aceptable. Encierre los caminos con espacios entre comillas. Necesita .csx con un código de nivel superior o un .cs/.csproj normal con un punto de entrada compatible 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. Uso en un bucle o condición: función de script

Parámetros y flujo de ejecución:

• Este es un ejemplo específico de uso compartido de comandos. La indexación de matrices comienza desde cero; Comprueba la longitud antes de manipularlo. UO.Wait(250), donde se usa, espera 250 milisegundos.
• Antes de los ejemplos, cree por separado los archivos Worker.csx especificados. Una ruta no válida/inaccesible, una ruta principal inapropiada, un C# deshabilitado o una ejecución paralela deshabilitada resultarán en una falla. Si la ejecución anterior aún está detenida, es posible realizar un reintento retrasado; aceptar el inicio no significa completarlo. Es posible que finalice un breve guión antes de leer la cantidad devuelta.
• int: número de ejecuciones activas desde la ejecución aceptada; 65535 (0xFFFF) = error de inicio. Este no es el índice del nuevo script, ni es un bool, ni es el resultado de su finalización.
• Obligatorio ScriptPath es una cadena. La ruta relativa comienza en la carpeta AutoLoad de este cliente; El camino absoluto es aceptable. Encierre los caminos con espacios entre comillas. Necesita .csx con un código de nivel superior o un .cs/.csproj normal con un punto de entrada compatible 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. Función auxiliar completa: clase de script

Parámetros y flujo de ejecución:

• Debajo de Main está la función completa. Sus parámetros y resultados se explican por separado del comando API que llama.
• TryStartCSharp compara el resultado con 65535 y devuelve true/false. No espera a que se complete y no convierte la cantidad en un índice.
• int: número de ejecuciones activas desde la ejecución aceptada; 65535 (0xFFFF) = error de inicio. Este no es el índice del nuevo script, ni es un bool, ni es el resultado de su finalización.
• Obligatorio ScriptPath es una cadena. La ruta relativa comienza en la carpeta AutoLoad de este cliente; El camino absoluto es aceptable. Encierre los caminos con espacios entre comillas. Necesita .csx con un código de nivel superior o un .cs/.csproj normal con un punto de entrada compatible 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;
}

Implementación del comando

C# distingue mayúsculas y minúsculas. Use el nombre UO exacto. Compare indicadores numéricos con 0; use bool solo si la firma devuelve bool.

UO.StartScript(scriptPath) — UO.StartScript(Any)

Parámetros: scriptPath (Any)

Resultado: int / Integer.

Durante la llamada:

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

Código interno de implementación; no es un script independiente.

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

---

UO.StopAllScripts

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

Firmas de C#

void UO.StopAllScripts();

Parámetros

No hay parámetros.

Valor devuelto

void: sin valor de retorno. No compares la llamada con true/1. Verifique la condición leyendo por separado GetScriptState; el resultado de dicha lectura es 0 (sin inicio), 1 (en funcionamiento), 2 (pausa).

Comportamiento

• Funciona sólo con ejecuciones de la sesión actual. Una pestaña abierta sin ejecución no es un inicio activo. La detención no elimina el archivo original ni desconecta la conexión al servidor.
• Los índices son dinámicos: las posiciones pueden moverse después de que se completa otra ejecución. Múltiples llamadas API no son una operación atómica. Los ejemplos están diseñados para la ausencia de cambios paralelos en la lista; busque la ejecución deseada nuevamente antes de la acción y no almacene el índice a través de UO.Wait.
• No hay argumentos. Se cancelan los procedimientos en ejecución y suspendidos, las consultas pendientes y la cola de repetición. El script de llamada también recibe una cancelación: no coloque el guardado/informe requerido después de este comando. Otros perfiles y procesos no se ven afectados.

Scripts independientes de C#

Cada ejemplo se puede guardar como un archivo independiente .csx y ejecutar en IDE. Las funciones de objeto UO y de espera proporcionan el anfitrión de la sesión de juego actual. Reemplace los nombres, coordenadas y direcciones de la demostración serial por los suyos propios.

Ejemplo sencillo

Ejecuta este código en un archivo .csx independiente. Los argumentos aparecen en la llamada; sustituye los nombres, seriales y direcciones de ejemplo por los tuyos.

El comando es una instrucción independiente. El mensaje anterior indica el inicio de la llamada y no confirma una acción del servidor.

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

1. Parada general incondicional - guión directo

Parámetros y flujo de ejecución:

• El comando tiene paréntesis vacíos. Realice el guardado deseado antes de llamar. El propio controlador también se detendrá.
• Los índices son dinámicos: las posiciones pueden moverse después de que se completa otra ejecución. Múltiples llamadas API no son una operación atómica. Los ejemplos están diseñados para la ausencia de cambios paralelos en la lista; busque la ejecución deseada nuevamente antes de la acción y no almacene el índice a través de UO.Wait.

UO.StopAllScripts();

2. Detenerse al morir el personaje - función de script

Parámetros y flujo de ejecución:

• Connected controla la entrada al mundo, Dead controla la muerte. StopAllScripts se llama solo cuando se cumplen ambas condiciones; el ejemplo los comprueba una vez.
• Los índices son dinámicos: las posiciones pueden moverse después de que se completa otra ejecución. Múltiples llamadas API no son una operación atómica. Los ejemplos están diseñados para la ausencia de cambios paralelos en la lista; busque la ejecución deseada nuevamente antes de la acción y no almacene el índice a través de 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. Parada general después de cinco segundos - clase de guión

Parámetros y flujo de ejecución:

• 5000 son los milisegundos en UO.Wait, no el parámetro StopAllScripts. La pausa manual o automática del controlador puede retrasar la ejecución; Este no es un cronómetro independiente.
• Los índices son dinámicos: las posiciones pueden moverse después de que se completa otra ejecución. Múltiples llamadas API no son una operación atómica. Los ejemplos están diseñados para la ausencia de cambios paralelos en la lista; busque la ejecución deseada nuevamente antes de la acción y no almacene el índice a través de 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;
    }
}

Implementación del comando

C# distingue mayúsculas y minúsculas. Use el nombre UO exacto. Compare indicadores numéricos con 0; use bool solo si la firma devuelve bool.

UO.StopAllScripts() — UO.StopAllScripts()

Parámetros: Sin parámetros.

Resultado: void / Unit.

Durante la llamada:

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

Código interno de implementación; no es un script independiente.

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

---

UO.StopScript

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

Firmas de C#

void UO.StopScript(object? scriptIndex);

Solicita la cancelación de un lanzamiento activo, incluido uno que está en pausa. Utilícelo cuando sea necesario completar esta ejecución en lugar de continuar más tarde.

Parámetros

• scriptIndex - Obligatorio ScriptIndex - índice de lanzamiento actual: 0 significa el primero, luego 1, 2... Consíguelo a través de GetScriptsList; no es serial, el nombre del archivo y no el resultado StartScript. Un índice negativo/faltante no cambia nada.

Valor devuelto

void: sin valor de retorno. No compares la llamada con true/1. Verifique la condición leyendo por separado GetScriptState; el resultado de dicha lectura es 0 (sin inicio), 1 (en funcionamiento), 2 (pausa).

Comportamiento

• Funciona sólo con ejecuciones de la sesión actual. Una pestaña abierta sin ejecución no es un inicio activo. La detención no elimina el archivo original ni desconecta la conexión al servidor.
• Los índices son dinámicos: las posiciones pueden moverse después de que se completa otra ejecución. Múltiples llamadas API no son una operación atómica. Los ejemplos están diseñados para la ausencia de cambios paralelos en la lista; busque la ejecución deseada nuevamente antes de la acción y no almacene el índice a través de UO.Wait.
• La cancelación es cooperativa: espera una pausa y el motor la controla; Las acciones ya enviadas al servidor no se cancelan. Un lanzamiento cancelado se elimina inmediatamente de la lista activa, aunque es posible que la liberación de recursos continúe. No verifique la finalización con el índice anterior: es posible que ya haya otra ejecución debajo de él.

Scripts independientes de C#

Cada ejemplo se puede guardar como un archivo independiente .csx y ejecutar en IDE. Las funciones de objeto UO y de espera proporcionan el anfitrión de la sesión de juego actual. Reemplace los nombres, coordenadas y direcciones de la demostración serial por los suyos propios.

Ejemplo sencillo

Ejecuta este código en un archivo .csx independiente. Los argumentos aparecen en la llamada; sustituye los nombres, seriales y direcciones de ejemplo por los tuyos.

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

1. Detener un procedimiento - guión directo

Parámetros y flujo de ejecución:

• MineOre — nombre de lanzamiento. -1 no se transfiere a StopScript. Después de detenerse, el índice guardado ya no se utiliza.
• Los índices son dinámicos: las posiciones pueden moverse después de que se completa otra ejecución. Múltiples llamadas API no son una operación atómica. Los ejemplos están diseñados para la ausencia de cambios paralelos en la lista; busque la ejecución deseada nuevamente antes de la acción y no almacene el índice a través de 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. Detener un inicio en pausa: función de script

Parámetros y flujo de ejecución:

• El código 2 selecciona una ejecución en pausa. StopScript lo finaliza en lugar de reanudarlo; otras tareas continúan.
• Los índices son dinámicos: las posiciones pueden moverse después de que se completa otra ejecución. Múltiples llamadas API no son una operación atómica. Los ejemplos están diseñados para la ausencia de cambios paralelos en la lista; busque la ejecución deseada nuevamente antes de la acción y no almacene el índice a través de 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. Dejar de ejecutar desde un archivo específico - clase de script

Parámetros y flujo de ejecución:

• La ruta absoluta selecciona la primera ejecución activa del archivo. Esto no es eliminar un archivo ni detener todos los procedimientos de ese archivo.
• Los índices son dinámicos: las posiciones pueden moverse después de que se completa otra ejecución. Múltiples llamadas API no son una operación atómica. Los ejemplos están diseñados para la ausencia de cambios paralelos en la lista; busque la ejecución deseada nuevamente antes de la acción y no almacene el índice a través de 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) ?? "");
}

Implementación del comando

C# distingue mayúsculas y minúsculas. Use el nombre UO exacto. Compare indicadores numéricos con 0; use bool solo si la firma devuelve bool.

UO.StopScript(scriptIndex) — UO.StopScript(Any)

Parámetros: scriptIndex (Any)

Resultado: void / Unit.

Durante la llamada:

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

Código interno de implementación; no es un script independiente.

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

---

UO.SubExists

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

Firmas de C#

int UO.SubExists(object? subrutineName);

Comprueba si el delegado C# con el nombre especificado está registrado con la ejecución actual. Este es un registro de funciones de devolución de llamada para una sesión determinada, sin buscar automáticamente métodos arbitrarios mediante la reflexión; Las entradas de archivos cargadas explícitamente también son accesibles mediante clave.

Parámetros

• subrutineName es el nombre de cadena dado por RegisterRoutine. Se eliminan los espacios en blanco alrededor de los bordes; Las búsquedas de nombres registrados no distinguen entre mayúsculas y minúsculas.

Valor devuelto

int: 1 - se cumple la condición, 0 - no se cumple. Guarde el resultado de una llamada si varias comprobaciones lo necesitan.

Comportamiento

• El registro y las tareas pertenecen a la misma ejecución. Otro personaje, perfil o ejecución posterior tiene su propio registro.
• RegisterRoutine acepta Action, Func<Task> o un delegado con una serie de argumentos de cadena para Exec. Eliminar el registro no ejecuta el código e impide realizar más búsquedas del nombre.
• El script principal debe permanecer activo mientras se necesitan sus ayudantes: una vez finalizado, las tareas se cancelan y se liberan los registros y suscripciones.
• FunRunning no es un índice de administrador. GetScriptsList y GetScriptState describen lanzamientos de archivos independientes; la devolución de llamada local no recibe un índice separado.
• El error de devolución de llamada se pasa al script principal en la siguiente verificación. Los bucles WaitAsync, UO.Wait y C# instrumentados admiten pausa, cancelación y procesamiento de cola de eventos.

Archivos C# cargados

Además de los delegados locales, el administrador actual admite entradas C# cargadas explícitamente con una clave como Child.csx::Main. SubExists y FunRunning aceptan dicha clave; CallSub ejecuta el archivo sin Args y Exec("exec Child.csx::Main 'north gate' 42") pasa Args. La clave con espacios está entre comillas dentro de Exec. Se acepta un nombre corto único, un nombre ambiguo no selecciona un archivo aleatorio. El registro local tiene prioridad. El lanzamiento de un archivo obtiene su propio contexto y duración en el mundo/administrador actual; Los delegados locales pertenecen a la ejecución que los registró.

Scripts independientes de C#

Cada ejemplo se puede guardar como un archivo independiente .csx y ejecutar en IDE. Las funciones de objeto UO y de espera proporcionan el anfitrión de la sesión de juego actual. Reemplace los nombres, coordenadas y direcciones de la demostración serial por los suyos propios.

Ejemplo sencillo

Ejecuta este código en un archivo .csx independiente. Los argumentos aparecen en la llamada; sustituye los nombres, seriales y direcciones de ejemplo por los tuyos.

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

1. Ejecute el procedimiento opcional disponible: script directo

Parámetros y flujo de ejecución:

• El comando devuelve int: en C# comprobar resultado!= 0 o resultado == 1; la comparación directa con true no es aceptable. La definición de WeightWatch se proporciona a continuación y se registra a través de RegisterRoutine antes de llamar al comando.
• Guarde el ejemplo como un archivo separado, cárguelo en IDE/manager y ejecute Main para que el resto de los procedimientos terminen en el directorio. WeightWatch/ManaWatch - procedimientos de entrenamiento completamente definidos aquí: tres mediciones de peso/mana con un intervalo de UO.Wait(1000), es decir, 1000 ms, salida solo al entrar al mundo. Este no es un monitoreo continuo; una pausa puede prolongar el tiempo. Para el ejemplo con dos tareas, se debe permitir el inicio simultáneo de procedimientos.

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. Seleccionar controlador de reserva - función de script

Parámetros y flujo de ejecución:

• WeightWatch se puede cargar desde otro archivo. Si no está presente, se selecciona el ManaWatch aquí declarado. Si se encuentra el primario pero no puede iniciarse, no habrá transición automática al secundario.
• Guarde el ejemplo como un archivo separado, cárguelo en IDE/manager y ejecute Main para que el resto de los procedimientos terminen en el directorio. WeightWatch/ManaWatch - procedimientos de entrenamiento completamente definidos aquí: tres mediciones de peso/mana con un intervalo de UO.Wait(1000), es decir, 1000 ms, salida solo al entrar al mundo. Este no es un monitoreo continuo; una pausa puede prolongar el tiempo. Para el ejemplo con dos tareas, se debe permitir el inicio simultáneo de procedimientos.

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. Verifique ambas definiciones antes de ejecutar - clase de script

Parámetros y flujo de ejecución:

• HaveMonitors prueba dos nombres usando &&. Si falta al menos uno, Main no llama a ninguna tarea. Se prueba un conjunto de definiciones, no una garantía de ejecución simultánea exitosa.
• Guarde el ejemplo como un archivo separado, cárguelo en IDE/manager y ejecute Main para que el resto de los procedimientos terminen en el directorio. WeightWatch/ManaWatch - procedimientos de entrenamiento completamente definidos aquí: tres mediciones de peso/mana con un intervalo de UO.Wait(1000), es decir, 1000 ms, salida solo al entrar al mundo. Este no es un monitoreo continuo; una pausa puede prolongar el tiempo. Para el ejemplo con dos tareas, se debe permitir el inicio simultáneo de procedimientos.

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);
}

Implementación del comando

C# distingue mayúsculas y minúsculas. Use el nombre UO exacto. Compare indicadores numéricos con 0; use bool solo si la firma devuelve bool.

UO.SubExists(subrutineName) — UO.SubExists(String)

Parámetros: subrutineName (String)

Resultado: int / Integer.

Durante la llamada:

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

Código interno de implementación; no es un script independiente.

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

Código interno de implementación; no es un script independiente.

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

---

UO.Terminate

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

Firmas de C#

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

Parámetros

• subrutineName — Cadena opcional. Sin argumento o con una cadena vacía se selecciona el último archivo iniciado; "all" solicita cancelar todas las ejecuciones. Para los archivos C#, usa una clave exacta del catálogo, por ejemplo harvest.csx::Main. Un nombre de callback local como Harvest solo funciona tras registrarlo explícitamente con RegisterRoutine. Un archivo tiene una entrada Main; los métodos de clase no se convierten automáticamente en procedimientos ejecutables independientes.

Valor devuelto

void: el comando no devuelve un número y no espera a que finalice el subproceso de trabajo. Ella inmediatamente solicita una cancelación. La ejecución se detiene en el siguiente cheque de cancelación; se interrumpen las pausas, los puntos de interrupción y las esperas integradas. Las acciones del servidor que ya se enviaron antes de la cancelación no se revierten.

Comportamiento

UO.FunRunning(name) == 0 también puede ocurrir inmediatamente después de solicitar la cancelación. No significa que el callback anterior haya terminado su bloque finally. Otro CallSub o Exec para el mismo nombre local se omite hasta que el trabajador anterior termina realmente.

• UO.Terminate() selecciona procedimientos por orden de ejecución en lugar de por nombre, línea del editor, hora de la última acción u orden de visualización. También se considera en ejecución un procedimiento pausado.
• El objetivo local perteneciente a esta carrera se borra y la ruta automática restante se cancela. La cancelación de movimiento se realiza en el hilo del juego; si la ruta ya ha sido reemplazada por otro recorrido o usuario, el propietario anterior no la detiene. Los pasos enviados al servidor no se recuperan.
• El comando permanece disponible cuando la configuración para un inicio simultáneo está habilitada. Un procedimiento cancelado libera espacio sólo después de que se haya borrado su subproceso de trabajo; Antes de esto, se omite el nuevo lanzamiento.
• La parada por nombre también cancela las correspondientes salidas pendientes. Los procedimientos completados no se modifican. El cliente informa la ausencia de un lanzamiento adecuado en el estado. Una llamada bloqueada a un complemento nativo de terceros que no admite la cancelación no se puede interrumpir de forma segura eliminando el hilo a la fuerza.

Scripts independientes de C#

Cada ejemplo se puede guardar como un archivo independiente .csx y ejecutar en IDE. Las funciones de objeto UO y de espera proporcionan el anfitrión de la sesión de juego actual. Reemplace los nombres, coordenadas y direcciones de la demostración serial por los suyos propios.

Para los archivos C#, usa una clave exacta del catálogo, por ejemplo harvest.csx::Main. Un nombre de callback local como Harvest solo funciona tras registrarlo explícitamente con RegisterRoutine. Un archivo tiene una entrada Main; los métodos de clase no se convierten automáticamente en procedimientos ejecutables independientes.

Ejemplo sencillo

Ejecuta este código en un archivo .csx independiente. Los argumentos aparecen en la llamada; sustituye los nombres, seriales y direcciones de ejemplo por los tuyos.

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

1. Dejar de cosechar por nombre, dejando otros procedimientos - guión directo

Esto solicita la cancelación de harvest.csx::Main que ya se está ejecutando. El mensaje no confirma el fin de su bloque finally ni revierte acciones de juego ya realizadas.

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

2. Seleccione Principal solo desde un archivo específico - función de script

La clave exacta harvest.csx::Main es distinta de heal.csx::Main. Sustitúyela por la clave de tu archivo cargado. Sufijos arbitrarios como #2 no crean otra entrada.

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

3. Formulario de consola compatible a través de Exec - clase de script

La cadena terminate harvest.csx::Main pasa la misma clave mediante UO.Exec. Una clave con espacios debe ir entre comillas dentro de la cadena 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. Detener la última ejecución cuando el estado sea bajo: script directo

Parámetros y flujo de ejecución:

• El formulario sin argumentos selecciona el último script en ejecución, incluido el que está en pausa. Esta es una política que da ejemplo, no una respuesta obligatoria a la mala salud; Se muestra un mensaje antes de la solicitud de cancelación.

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

Implementación del comando

C# distingue mayúsculas y minúsculas. Use el nombre UO exacto. Compare indicadores numéricos con 0; use bool solo si la firma devuelve bool.

UO.Terminate() — UO.Terminate()

Parámetros: Sin parámetros.

Resultado: void / Unit.

Durante la llamada:

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

Código interno de implementación; no es un script independiente.

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

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

Parámetros: subrutineName (String)

Resultado: void / Unit.

Durante la llamada:

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

Código interno de implementación; no es un script independiente.

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;

Código interno de implementación; no es un script independiente.

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

---

UO.TerminateAll

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

Firmas de C#

void UO.TerminateAll();

Parámetros

No hay parámetros.

Valor devuelto

void: sin resultado. El comando solicita la cancelación de todas las ejecuciones actuales y devuelve el control al código de llamada si no se ha cancelado. Los hilos de trabajo se limpian después de que se activan sus comprobaciones de cancelación.

Comportamiento

• La sintaxis exacta es UO.TerminateAll(), sin espacios dentro del nombre ni argumentos. UO.Terminate("all") se admite como notación alternativa compatible.
• Detiene la ejecución de procedimientos, procedimientos pausados ​​manualmente y con puntos de interrupción, esperas integradas y ejecuciones retrasadas registradas. Volver a llamar cuando no hay trabajo es seguro.
• Al eliminar las vistas locales y las rutas automáticas se tienen en cuenta sus propietarios. La ruta restante del script detenido se cancela en el hilo del juego; Se guarda la nueva ruta del usuario que la reemplazó. Los paquetes de mociones ya enviados no se cancelan.
• Cancelar no revierte las acciones ya enviadas al servidor. El código de complemento nativo de terceros sin soporte de cancelación no se puede destruir de forma segura junto con la transmisión. Se permiten nuevos inicios explícitos después de la ejecución del comando; cuando la casilla de verificación está habilitada, esperan a que se libere espacio en el sentido de que el intento se omite en lugar de ponerse en cola hasta que se complete la limpieza.

Scripts independientes de C#

Cada ejemplo se puede guardar como un archivo independiente .csx y ejecutar en IDE. Las funciones de objeto UO y de espera proporcionan el anfitrión de la sesión de juego actual. Reemplace los nombres, coordenadas y direcciones de la demostración serial por los suyos propios.

Ejemplo sencillo

Ejecuta este código en un archivo .csx independiente. Los argumentos aparecen en la llamada; sustituye los nombres, seriales y direcciones de ejemplo por los tuyos.

El comando es una instrucción independiente. El mensaje anterior indica el inicio de la llamada y no confirma una acción del servidor.

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

1. Evite que todos los scripts se revisen dentro de un script en funcionamiento: script directo

Parámetros y flujo de ejecución:

• TerminateAll no tiene parámetros. La condición UO.Dead() verifica la muerte del personaje antes de la siguiente iteración.
• Cuando se cumple la condición, se cancelan tanto la ejecución principal actual como las restantes C#. El mensaje Print se ubica antes de la parada, ya que después de ella se detiene el código de este procedimiento.
• WaitAsync(250) especifica la pausa 250 milisegundos entre comprobaciones en este ejemplo. El comando de parada no cambia la duración de las pausas normales del 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. Formulario compatible con todos - función de script

Parámetros y flujo de ejecución:

• Esta notación alternativa utiliza UO.Terminate con un parámetro subrutineName="todo". Este es el equivalente a UO.TerminateAll().
• La cadena all es un valor especial, no el nombre del procedimiento que debe declararse. EmergencyStop también se cancela.
• Para la clave del juego de emergencia, utilice el comando de una línea del primer ejemplo: el procedimiento separado EmergencyStop está sujeto a la prohibición de ejecuciones paralelas.

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

3. Detener la operación general si un objeto requerido deja de estar disponible - clase de script

Parámetros y flujo de ejecución:

• GetSerial almacena serial el objeto requerido, aquí su propia mochila. Exists=0 significa que este objeto es actualmente desconocido para el cliente.
• TerminateAll se llama sin argumentos solo cuando se viola la condición seleccionada. Esta política detiene todos los procedimientos, no solo el trabajo en una mochila determinada.
• En primer lugar, se muestra el motivo de la parada. Una vez realizada una solicitud de cancelación, también se da por terminado el procedimiento actual; No se puede contar con la siguiente acción.

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. Detenga todo el trabajo después de perder la conexión: secuencia de comandos directa

Parámetros y flujo de ejecución:

• Si no hay conexión, se detienen todos los inicios. El comando no devuelve el número de scripts cancelados y también cancela la ejecución actual.

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

Implementación del comando

C# distingue mayúsculas y minúsculas. Use el nombre UO exacto. Compare indicadores numéricos con 0; use bool solo si la firma devuelve bool.

UO.TerminateAll() — UO.TerminateAll()

Parámetros: Sin parámetros.

Resultado: void / Unit.

Durante la llamada:

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

Código interno de implementación; no es un script independiente.

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

---

UO.Time

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

Firmas de C#

int UO.Time();

Lee la hora local del día de la computadora usando el número HHMMSS. Conveniente para seleccionar el tiempo de funcionamiento permitido, no para medir la duración.

Parámetros

No hay parámetros.

Valor devuelto

int HHMMSS, 0..235959 con minutos y segundos válidos. 07:29:35 -> 72935; medianoche -> 0. Cero es un tiempo válido, no un error o una bandera lógica false.

Comportamiento

• No hay parámetros, ni formularios con argumentos. Los paréntesis vacíos solo leen la hora: la llamada no espera, no inicia un cronómetro ni envía paquetes al juego.
• RealTimeSource. Ahora se lee DateTime. Ahora: la fecha/hora local de la computadora, no UTC, ni la hora del fragmento ni el reloj del juego. La zona horaria, el horario de verano y el cambio manual del reloj afectan los resultados. Cada llamada captura un momento diferente.
• Los ceros a la izquierda no se conservan ni los milisegundos. Numéricamente, 13:00:00 menos 12:59:59 da 4041, aunque haya pasado un segundo. A medianoche el valor vuelve a ser cero.
• No reste los códigos del calendario para calcular el retraso. Utilice Timer() y dos marcas de una ejecución. El reloj del calendario puede retroceder.

Scripts independientes de C#

Cada ejemplo se puede guardar como un archivo independiente .csx y ejecutar en IDE. Las funciones de objeto UO y de espera proporcionan el anfitrión de la sesión de juego actual. Reemplace los nombres, coordenadas y direcciones de la demostración serial por los suyos propios.

Ejemplo sencillo

Ejecuta este código en un archivo .csx independiente. Los argumentos aparecen en la llamada; sustituye los nombres, seriales y direcciones de ejemplo por los tuyos.

El resultado de una sola llamada se muestra en el diario. Un número no se convierte en bool; para un array se muestra su cantidad de elementos.

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

1. Mostrar campos de tiempo individuales - script directo

Parámetros y flujo de ejecución:

• El sello se lee una vez para no mezclar segundos diferentes. Int(sello/10000) — horas; Int(sello/100) MOD 100 — minutos; MOD 100 – segundos. Una cadena simple no rellena los campos con ceros.

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. Permitir series solo en horario nocturno - función de guión

Parámetros y flujo de ejecución:

• 180000 - 18:00:00 inclusive; 220000 - 22:00:00 no incluido. Una verificación decide si continuar con Main. El horario no queda registrado y la serie no comienza automáticamente.

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. Considere el intervalo después de medianoche - clase de escenario

Parámetros y flujo de ejecución:

• ClockInWindow(sello,primero,último) acepta HHMMSS válido. 230000..20000 significa desde 23:00 inclusive hasta 02:00 no inclusivo: OR tiene en cuenta la medianoche. Límites iguales significan intervalo vacío. Durante el período de tranquilidad, Main termina; La función se da en su totalidad.

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;
}

Implementación del comando

C# distingue mayúsculas y minúsculas. Use el nombre UO exacto. Compare indicadores numéricos con 0; use bool solo si la firma devuelve bool.

UO.Time() — UO.Time()

Parámetros: Sin parámetros.

Resultado: int / Integer.

Durante la llamada:

• InjectionScript.Runtime.InjectionApiUO.Time.

Código interno de implementación; no es un script independiente.

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 · 繁體中文 · 日本語 · 한국어

Firmas de C#

int UO.Timer();

Lee el tiempo de ejecución del tiempo de ejecución actual en décimas de segundo. Adecuado para sus propios retrasos y marcas de acción.

Parámetros

No hay parámetros.

Valor devuelto

int 0..2147483647; la unidad es 100 ms. En 399 se devolverá ms 3. Esta es la lectura del reloj, no true/false ni la recarga restante.

Comportamiento

• No hay parámetros, ni formularios con argumentos. Los paréntesis vacíos solo leen la hora: la llamada no espera, no inicia un cronómetro ni envía paquetes al juego.
• El origen pertenece a esta instancia de tiempo de ejecución. Un nuevo procedimiento en ejecución puede recibir un nuevo reloj; No puede comparar valores de diferentes ejecuciones ni almacenarlos como una fecha absoluta. Durante UO.Wait y una pausa del guión, el tiempo real continúa corriendo.
• Se descarta la parte fraccionaria de las décimas. Después de aproximadamente 2485.5 días, el número llega a 2147483647 y permanece allí sin desbordarse.
• Este es su retraso, no un tiempo de reutilización del servidor de una habilidad/hechizo o una confirmación de éxito. El comando no le permite eludir las restricciones del servidor sobre movimiento, hechizos o scripts.

Scripts independientes de C#

Cada ejemplo se puede guardar como un archivo independiente .csx y ejecutar en IDE. Las funciones de objeto UO y de espera proporcionan el anfitrión de la sesión de juego actual. Reemplace los nombres, coordenadas y direcciones de la demostración serial por los suyos propios.

Ejemplo sencillo

Ejecuta este código en un archivo .csx independiente. Los argumentos aparecen en la llamada; sustituye los nombres, seriales y direcciones de ejemplo por los tuyos.

El resultado de una sola llamada se muestra en el diario. Un número no se convierte en bool; para un array se muestra su cantidad de elementos.

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

1. Medir la duración de una operación - script directo

Parámetros y flujo de ejecución:

• WaitAsync(250) solicita 250 ms; El retraso real puede ser mayor. La diferencia entre las dos marcas se divide por 10.0 para obtener los segundos. Paso de indicación 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. Limite la espera de una mira ya solicitada a tres segundos: función de script

Parámetros y flujo de ejecución:

• El límite 30 se da en unidades de esta función. UO.Wait(50) libera la ejecución entre comprobaciones. UO.Targeting lee la presencia de una vista; El ejemplo no lanza ni apunta. Si la vista no aparece, el ciclo finaliza.
• Una comprobación adicional del límite superior finaliza la espera incluso si el contador se ha detenido en el límite int. El estado del osciloscopio se lee repetidamente y puede cambiar entre lecturas.

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. Función de intervalo de reintento personalizado: clase de secuencia de comandos

Parámetros y flujo de ejecución:

• IntervalPassed(iniciado, actual, intervalo) está completamente definido en Principal. intervalo=5 — medio segundo en unidades de este reloj. Intervalo negativo, inversión y int en el límite superior dan false; lograr el intervalo exactamente da true.
• Este es su retraso, no un tiempo de reutilización del servidor de una habilidad/hechizo o una confirmación de éxito. El comando no le permite eludir las restricciones del servidor sobre movimiento, hechizos o scripts.

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;
}

Implementación del comando

C# distingue mayúsculas y minúsculas. Use el nombre UO exacto. Compare indicadores numéricos con 0; use bool solo si la firma devuelve bool.

UO.Timer() — UO.Timer()

Parámetros: Sin parámetros.

Resultado: int / Integer.

Durante la llamada:

• InjectionScript.Runtime.InjectionApiUO.Timer.

Código interno de implementación; no es un script independiente.

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

---

UO.Wait

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

Firmas de C#

void UO.Wait(object? waitTimeMS);

Pausa el script actual durante el número especificado de milisegundos. Útil entre comprobaciones de estado repetidas para evitar que el script se ejecute en un bucle continuo.

Parámetros

• waitTimeMS — Tiempo entero en milisegundos: 1000 = un segundo. Utilice 0...2147483647. Este no es el número de pasos, ni los segundos, ni el tiempo de espera de confirmación del servidor.

Valor devuelto

void - sin resultado. Llame en una línea separada. El final del retraso no significa que el objeto se haya movido, que el hechizo se haya completado o que se haya establecido la conexión: verifique el estado deseado por separado.

Comportamiento

• Zero no crea ningún retraso real y no es adecuado como pausa en un bucle rápido. El tiempo negativo no significa infinito: UO.Wait lo reduce a 0; UO.Wait/sleep puede rechazarlo con devoluciones de llamada activas, y en el puente del cliente sin ellas no esperará. Para una secuencia de comandos portátil, utilice únicamente tiempos no negativos.

Ejemplo .csx

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

Scripts independientes de C#

Cada ejemplo se puede guardar como un archivo independiente .csx y ejecutar en IDE. Las funciones de objeto UO y de espera proporcionan el anfitrión de la sesión de juego actual. Reemplace los nombres, coordenadas y direcciones de la demostración serial por los suyos propios.

Ejemplo sencillo

Ejecuta este código en un archivo .csx independiente. Los argumentos aparecen en la llamada; sustituye los nombres, seriales y direcciones de ejemplo por los tuyos.

El comando es una instrucción independiente. El mensaje anterior indica el inicio de la llamada y no confirma una acción del servidor.

UO.Print("Calling UO.Wait");
UO.Wait(250);

1. UO.Wait - 1 - guión directo

Parámetros y flujo de ejecución:

• 250 - cuarto de segundo. La siguiente línea se ejecuta después de esperar; El mensaje de retraso completo es el texto del ejemplo, no el resultado devuelto.

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

2. UO.Wait — 2 — función de secuencia de comandos

Parámetros y flujo de ejecución:

• WaitForOnline está completamente declarado en este script. El argumento 20 significa un máximo de veinte pausas de 250 ms. La conexión se comprueba antes de las pausas y nuevamente después de la última. El ayudante devuelve el estado Connected (1/0); El comando de espera en sí no devuelve nada y no se conecta al servidor.

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 - clase de escenario

Parámetros y flujo de ejecución:

• El bucle realiza exactamente tres lecturas de peso. Entre lecturas hay dos pausas de 500 ms, después de la última no hay pausa. Se imprime un mensaje la primera vez que se lee y cuando cambia el peso. La variable anterior almacena el valor a comparar, en lugar de ajustar el peso del juego.

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;
}

Implementación del comando

C# distingue mayúsculas y minúsculas. Use el nombre UO exacto. Compare indicadores numéricos con 0; use bool solo si la firma devuelve bool.

UO.Wait(waitTimeMS) — UO.Wait(Any)

Parámetros: waitTimeMS (Any)

Resultado: void / Unit.

Durante la llamada:

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

Código interno de implementación; no es un script independiente.

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;
        }
    }

Código interno de implementación; no es un script independiente.

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

---

UO.Waiting

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

Firmas de C#

int UO.Waiting();

Comprueba si las respuestas preparadas permanecen en la cola de destino.

Parámetros

No hay parámetros.

Valor devuelto

int 1: hay un objetivo diferido no cancelado de un objeto, mosaico o cancelación de la siguiente vista; 0: la cola está vacía. Es no tener un cursor abierto; para el cursor utilice TargetPresent/Targeting.

El resultado del comando es una bandera numérica: 1 significa una condición cumplida, 0 significa una condición no cumplida. Después de var resultado = comando(...) verifique si (resultado! = 0) o si (resultado == 0). Guarde el resultado de una llamada: una llamada repetida puede realizar la acción nuevamente o leer el estado que ya cambió.

Comportamiento

• Se lee toda la cola del cliente. Si se ejecutan varios procedimientos simultáneamente, se tienen en cuenta las respuestas de cada uno de ellos.
• Cero sólo significa que no hay respuesta pendiente. No confirma el uso exitoso de una habilidad o hechizo en el servidor.

Scripts independientes de C#

Cada ejemplo se puede guardar como un archivo independiente .csx y ejecutar en IDE. Las funciones de objeto UO y de espera proporcionan el anfitrión de la sesión de juego actual. Reemplace los nombres, coordenadas y direcciones de la demostración serial por los suyos propios.

Ejemplo sencillo

Ejecuta este código en un archivo .csx independiente. Los argumentos aparecen en la llamada; sustituye los nombres, seriales y direcciones de ejemplo por los tuyos.

El resultado de una sola llamada se muestra en el diario. Un número no se convierte en bool; para un array se muestra su cantidad de elementos.

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

1. Preparación del cheque - guión directo

Parámetros y flujo de ejecución:

• Después de WaitTargetSelf y antes de que se espere el destino del servidor 1.
• CancelWaitTarget borra la cola; la siguiente prueba da 0.

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

2. Esperar de forma limitada a que se gaste la respuesta: función de script

Parámetros y flujo de ejecución:

• El cheque no tiene parámetros. UO.Wait=50 ms, expectativas máximas de 20.
• Si la respuesta permanece, se cancela. Agregue una verificación del resultado de la acción del servidor por separado.

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. Mostrar diferencia entre cola y vista - clase de script

Parámetros y flujo de ejecución:

• La primera línea muestra las respuestas diferidas, la segunda, el estado de la vista.
• Son posibles una cola sin cursor y un cursor sin cola; Estos valores no son intercambiables.

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;
    }
}

Implementación del comando

C# distingue mayúsculas y minúsculas. Use el nombre UO exacto. Compare indicadores numéricos con 0; use bool solo si la firma devuelve bool.

UO.Waiting() — UO.Waiting()

Parámetros: Sin parámetros.

Resultado: int / Integer.

Durante la llamada:

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

Código interno de implementación; no es un script independiente.

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