ES UO Topic character

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

Personaje

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

El estado de tu personaje, características, resistencias y equipamiento. Para una entidad específica, use la sobrecarga serial si está en la tarjeta de comando.

Secciones

Tema	Comandos y explicaciones
Identity	UO.Self · UO.GetSerial · UO.GetName · UO.GetTitle · UO.GetSex · UO.GetRace
Stats	UO.HP · UO.MaxHP · UO.Mana · UO.MaxMana · UO.Stamina · UO.MaxStamina · UO.Str · UO.Dex · UO.Int · UO.Weight · UO.MaxWeight · UO.Luck · UO.GetStatLockState · UO.SetStatLockState
Status	UO.Alive · UO.Dead · UO.Hidden · UO.Poisoned · UO.Frozen · UO.Paralyzed · UO.Flying · UO.WarMode · UO.IsYellowHits
Resists	UO.PhysicalResist · UO.GetPhysicalResist · UO.ResistPhysical · UO.GetResistPhysical · UO.FireResist · UO.GetFireResist · UO.ResistFire · UO.GetResistFire · UO.ColdResist · UO.GetColdResist · UO.ResistCold · UO.GetResistCold · UO.PoisonResist · UO.GetPoisonResist · UO.ResistPoison · UO.GetResistPoison · UO.EnergyResist · UO.GetEnergyResist · UO.ResistEnergy · UO.GetResistEnergy · UO.GetResist
Capas de personajes	UO.ObjAtLayer · UO.ObjAtLayerEx · UO.GetLayer · UO.GetEquipment
Equipment	UO.GetEquipment · UO.EquipItems · UO.UnequipItems · UO.WearItem
Dress / Undress	UO.SetDress · UO.Dress · UO.Undress · UO.DressSavedSet
Arm / Disarm	UO.SetArm · UO.Arm · UO.Disarm
Mount / Dismount	UO.Mount · UO.Dismount
Paperdoll	UO.UseSelfPaperdollScroll · UO.UseOtherPaperdollScroll

Todos los comandos del tema

Capas de personajes

Todas las capas: finalidad, significados y ejemplos. El número de capa, serial del elemento equipado y su graphic son valores diferentes.

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

Parámetros, resultado y todos los escenarios

var value = UO.HP();
UO.Print("HP: " + Convert.ToString(value));

UO.ObjAtLayer

Parámetros, resultado y todos los escenarios

object? hand = UO.ObjAtLayer("Rhand");
if (hand is string serial)
{
    UO.Print("Right hand serial: " + serial);
}
else
{
    UO.Print("Right hand is empty or unavailable");
}

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

Partes de la referencia

1 · 2 · 3 · 4 · 5

Referencia completa de comandos

UO.Alive

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

Firmas de C#

int UO.Alive();
int UO.Alive(object? value);

Comprueba la presencia de un objeto sin signos de muerte.

Parámetros

value: objeto opcional en los formularios que se muestran: serial por número/cadena hexadecimal, self, lasttarget o nombre registrado AddObject. Esto no es type. Sin argumentos, lea self. El texto desconocido en algunos formularios provoca un error de conversión; Verifique el nombre antes de llamar.

Valor devuelto

Bandera numérica int: 1 (condición cumplida), 0 (condición no cumplida). Esta es una bandera numérica: en C# verifique el resultado! = 0 o resultado == 0. Comparación directa de int con true/false y si (resultado) no está permitido. 1: el serial positivo existe y no está marcado como muerto. El famoso elemento también indica 1: este no es el filtro mobile. Un objeto muerto/perdido da 0.

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

Lee el modelo local: no abre el destino, no solicita el estado, no cambia la bandera y no envía el paquete. Un objeto destruido se considera perdido incluso antes de que la entrada se elimine del diccionario.
El resultado es una lectura separada. El mundo puede cambiar entre Exists y el próximo desafío; varias consultas no forman una instantánea atómica.

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

1. Comprueba tu propio estado - guión directo

Parámetros y flujo de ejecución:

Los paréntesis vacíos dicen self. activo guarda el resultado una vez; true y false definen dos ramas. Print solo muestra un mensaje de ejemplo.

var active = UO.Alive();
if (Truth(Truth(active) == true))
{
    UO.Print("State is active");
}
else
{
    UO.Print("State is inactive or unavailable");
}

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

2. Objeto seleccionado y función completa ReadState - función de script

Parámetros y flujo de ejecución:

lasttarget – objeto previamente seleccionado. Exists comprueba su presencia. obj es el único parámetro ReadState; la función devuelve el resultado del comando sin modificación. Su definición está incluida en el código copiado.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Exists("lasttarget")))
    {
        var observed = ReadState("lasttarget");
        UO.Print("State 1/0: " + Convert.ToString(observed));
    }

    return null;
}

dynamic ReadState(dynamic obj)
{
    return UO.Alive(obj);
}

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

3. Observe un cambio en medio segundo - clase de script

Parámetros y flujo de ejecución:

Dos llamadas sin argumentos leen self, UO.Wait(500) establece 500 milisegundos. Se comparan dos imágenes; se pueden omitir las transiciones intermedias. No hay una espera interminable.

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

    async public Task<object?> RunScenarioAsync()
    {
        var before = UO.Alive();
        await Delay(500);
        var after = UO.Alive();
        if (Truth(before != after))
        {
            UO.Print("State changed: " + Convert.ToString(before) + " -> " + Convert.ToString(after));
        }

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

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

Parámetros: Sin parámetros.

Resultado: int / Integer.

Durante la llamada:

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [Alive].
InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Exists: bridge.Exists(serial).
InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::IsDeadState: IsDeadState(serial).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self: bridge.Self.

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.

serial => serial > 0 && bridge.Exists(serial) != 0 && IsDeadState(serial) == 0 ? 1 : 0

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

() => getter(bridge.Self)

Creación de API: Estas funciones registran la API. No se ejecutan de nuevo en cada llamada al comando.

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddState.

`UO.Alive(value)` — `UO.Alive(Any)`

Parámetros: value (Any)

Resultado: int / Integer.

Durante la llamada:

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [Alive].
InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Exists: bridge.Exists(serial).
InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::IsDeadState: IsDeadState(serial).
InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(value).

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.

serial => serial > 0 && bridge.Exists(serial) != 0 && IsDeadState(serial) == 0 ? 1 : 0

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

value => getter(GetObject(value))

Creación de API: Estas funciones registran la API. No se ejecutan de nuevo en cada llamada al comando.

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddState.

UO.Arm

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

Firmas de C#

void UO.Arm(object? name);

Restaura un conjunto de armas y escudos con nombre previamente guardado.

Parámetros

name: nombre de cadena del conjunto, como "viaje" o "batalla". Los nombres no distinguen entre mayúsculas y minúsculas. Los conjuntos de ropa y armas se almacenan por separado: se permite el mismo nombre en ambos. Esto no es una cosa ID ni un nombre de archivo. Sólo SetDress permite la ausencia de un nombre: entonces se registra un conjunto separado para DressSavedSet/EquipDressSet.

Valor devuelto

void - sin valor. Llame en una línea separada; no asigne el resultado ni lo compare con true. Guardar y eliminar cambia la entrada, no el equipo.

Comportamiento

Ropa: capas 3,4,5,6,7,8,10,12,13,14,17,18,19,20,22,23,24. Armas: 1 y 2 únicamente. Pelo, barba, mochila, animal y banco no están incluidos en estos sets.
Los elementos específicos serial ya cargados se registran en sus propias capas. Guardar el mismo nombre nuevamente reemplaza la entrada. Las capas vacías también tienen sentido: cuando se restauren, la capa ocupada correspondiente se liberará en su propia mochila. Por lo tanto, un conjunto guardado completamente vacío elimina elementos de sus capas.
El conjunto se almacena en el estado de tiempo de ejecución. La llamada en sí no crea un archivo y no garantiza que el conjunto se transfiera a otro perfil o a un nuevo tiempo de ejecución. Primero, guarde el conjunto deseado en su estado usado. Cargar/guardar el estado general del cliente es un mecanismo separado.
Se omite una coincidencia exacta entre el ID actual y el guardado, sin volver a utilizarlo o generarlo. Un elemento faltante no se reemplaza por un type similar. El fracaso de una operación no anula las exitosas ni interfiere con los intentos de otras; No hay reversión automática. Necesita conexión y cosas cargadas. Cuando se retira, se utiliza una mochila real.
UO.Set("equipfordress", 0) selecciona la solicitud para utilizar el elemento (modo inicial); valor distinto de cero - recogida/equipamiento. La capa portátil deseada se comprueba en ambos modos. Un artículo ya usado no se puede cambiar mediante un uso repetido. DressSpeed es válido después de la solicitud aceptada, el retiro respeta adicionalmente DropDelay.
Dress y Arm devuelven void incluso en caso de falla. El mensaje de que las solicitudes han sido aceptadas no significa confirmación por parte del servidor. Para una continuación que depende de la colocación, verifique las capas reales con expectativas limitadas.
UO.SetDress · UO.Dress · UO.DressSavedSet · UO.SetArm · UO.Arm · UO.DressSpeed

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

1. Uso directo - guión directo

Parámetros y flujo de ejecución:

El conjunto requerido debe guardarse anteriormente en el mismo estado de ejecución. No llame a SetDress/SetArm justo antes de cada restauración: esto sobrescribirá el objetivo con los elementos actuales.

UO.Arm("battle");

2. Nombres y modo de consulta: función de secuencia de comandos

Parámetros y flujo de ejecución:

Un equipo distinto de cero selecciona recoger/equipar; 350 — milisegundos DressSpeed. Estas configuraciones permanecen en tiempo de ejecución después del ejemplo. La retirada y colocación la decide el servidor.

return  RunScenario();
 object? RunScenario()
{
    UO.Set("equipfordress", 1);
    UO.DressSpeed(350);
    UO.Arm("battle");
    return null;
}

3. Script auxiliar completo - Clase de script

Parámetros y flujo de ejecución:

lasttarget: ID cosas que deberían incluirse en un conjunto previamente guardado. La capa de control 3 significa zapatos, 1 significa mano derecha. AwaitSlot compensa hasta 20 comprobaciones con una pausa de 100 ms y no repite el comando. Esto confirma sólo el elemento seleccionado, no todo el conjunto.

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 expected = Asc(UO.GetSerial("lasttarget"), 0);
        if (Truth(expected == 0))
        {
            return 0;
        }

        UO.Arm("battle");
        return AwaitSlot(1, expected);
        return null;
    }

    dynamic AwaitSlot(dynamic layer, dynamic expected)
    {
        for (int attempt = (int)(1); attempt <= 20; attempt += (int)(1))
        {
            if (Truth(UO.ObjAtLayerEx(layer, UO.Self()) == expected))
            {
                return 1;
            }

            UO.Wait(100);
        }

        return 0;
    }

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

    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.Arm(name)` — `UO.Arm(String)`

Parámetros: name (String)

Resultado: void / Unit.

Durante la llamada:

InjectionScript.Runtime.InjectionApiUO.Arm.
InjectionScript.Runtime.InjectionApiUO.Equip: Equip(name, armSets, weaponLayers, "Weapon set requests processed.", "No weapons set with setarm.").

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

public void Arm(string name)

            => Equip(name, armSets, weaponLayers, "Weapon set requests processed.", "No weapons set with setarm.");

UO.Armor

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

Firmas de C#

int UO.Armor();

Lee el campo de resistencia del personaje actual: armadura física/resistencia.

Parámetros

No hay parámetros.

Valor devuelto

int: valor de estado firmado, -32768..32767 en el modelo de cliente. El valor negativo se mantiene. 0 puede ser una resistencia real, falta de datos o un jugador perdido/destruido; GetResist también da 0 para un selector desconocido. Esto no es un límite bool, ID, de habilidad o resistencia. 1 significa un punto, no éxito.

Comportamiento

El comando no acepta argumentos. Utilice las firmas exactas anteriores.
La lectura del hilo del juego requiere Jugador.PhysicalResistance si el Jugador actual existe y no ha sido destruido; en caso contrario 0. El equipo no se clasifica, las bonificaciones no se recalculan, no se solicita el estado y no hay que esperar actualizaciones. Un fantasma presente no es igual a un Jugador destruido.
PhysicalResistance - campo de armadura/estado del servidor: el servidor clásico puede transmitir la clasificación de armadura y las reglas con resistencias pueden transmitir resistencia física. API no convierte de uno a otro y no calcula el porcentaje de reducción de daño. Armor y los alias físicos leen el mismo campo.
CharacterStatus verifica el cuerpo requerido antes de cambiar el nombre, la salud y las características propias, luego traduce cada palabra de resistencia a un Int16 firmado. Un cuerpo obligatorio recortado no modifica los datos anteriores. La cola opcional type 6 conserva las mismas reglas; Los comandos de resistencia no leen los límites máximos.
Cada llamada lee los datos locales de nuevo. La variable almacena la instantánea; las lecturas individuales pueden recibir diferentes actualizaciones del servidor. Un resultado distinto de cero no prueba la conexión. Cero puede ser un valor o ningún dato.
Estas funciones registran la API. No se ejecutan de nuevo en cada llamada al 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.

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

1. Imprimir valor guardado - script directo

Parámetros y flujo de ejecución:

El valor almacena el resultado de una llamada. Convertir.ToString formatea el número del registro. No hay argumentos: puedes leer tu propio personaje.

var value = UO.Armor();
UO.Print("PhysicalResistance: " + Convert.ToString(value));

2. Comparar dos imágenes - función de script

Parámetros y flujo de ejecución:

Entre antes y después hay UO.Wait(500) milisegundos; la diferencia puede ser negativa. Es posible que se pierdan actualizaciones provisionales. La pausa se refiere al ejemplo, no al retraso API.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.Armor();
    await Delay(500);
    var after = UO.Armor();
    var difference = after - before;
    UO.Print("Resistance change: " + Convert.ToString(difference));
    return null;
}

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

3. Función de prueba de resistencia mínima completa: clase de script

Parámetros y flujo de ejecución:

mínimo=50 es un ejemplo de requisito, no de límite de clientes. ResistanceAtLeast rechaza al jugador que falta, lee un valor y devuelve bool: true o false si el valor >= mínimo. La resistencia en sí no es bool. La función se declara completamente a continuació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()
    {
        if (Truth(Truth(ResistanceAtLeast(50)) == true))
        {
            UO.Print("Local resistance requirement met");
        }
        else
        {
            UO.Print("Requirement not met or no player");
        }

        return null;
    }

    dynamic ResistanceAtLeast(dynamic minimum)
    {
        if (Truth(UO.Self() == 0))
        {
            return false;
        }

        var value = UO.Armor();
        return value >= minimum;
    }

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

Parámetros: Sin parámetros.

Resultado: int / Integer.

Durante la llamada:

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

case "armor": return new InjectionValue(bridge.Armor);

UO.CharName

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

Firmas de C#

dynamic UO.CharName();

Lee el nombre del personaje.

Parámetros

No hay parámetros.

Valor devuelto

string es un nombre conocido por el cliente. Una cadena vacía significa un valor vacío/desconocido o ningún objeto. Esto no es serial ni una ruta de perfil. El nombre/título del juego no está traducido al idioma IDE.

Comportamiento

Se leen los datos locales ya recibidos. La solicitud no abre el estado y no obliga al servidor a enviar una actualización. Después de la muerte, la transición del mapa o la eliminación de un objeto, los valores pueden cambiar entre dos llamadas.
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.

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

1. Mostrar texto después de iniciar sesión: script directo

Parámetros y flujo de ejecución:

No hay parámetros: se lee self.
La cadena vacía se maneja explícitamente; este no es el texto "0".

var text = UO.CharName();
if (Truth(text != ""))
{
    UO.Print(text);
}
else
{
    UO.Print("Text is unavailable");
}

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

2. Agregar texto al mensaje de registro: función de secuencia de comandos

Parámetros y flujo de ejecución:

Se lee su carácter, el valor se almacena como una línea.
El operador + une cadenas; Convert.ToString no es necesario para este resultado.

return  RunScenario();
 object? RunScenario()
{
    var text = UO.CharName();
    UO.Print("Player имя: " + text);
    return null;
}

3. Comparar dos instantáneas - clase de escenario

Parámetros y flujo de ejecución:

Ambas llamadas se refieren a self; UO.Wait establece la pausa 1000 ms.
La diferencia puede significar actualizar datos o abandonar el mundo. El ejemplo no cambia el nombre ni el título.

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 previous = UO.CharName();
        await Delay(1000);
        var current = UO.CharName();
        if (Truth(previous != current))
        {
            UO.Print("Updated text: " + current);
        }

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

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

Parámetros: Sin parámetros.

Resultado: dynamic / Any.

Durante la llamada:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetName: bridge.GetName(Arg(0, bridge.Self)).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0, bridge.Self).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self: bridge.Self.

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

case "getname":

                case "charname": return new InjectionValue(bridge.GetName(Arg(0, bridge.Self)));

UO.CharTitle

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

Firmas de C#

dynamic UO.CharTitle();

Lee el título del personaje.

Parámetros

No hay parámetros.

Valor devuelto

string es un título conocido por el cliente. Una cadena vacía significa un valor vacío/desconocido o ningún objeto. Esto no es serial ni una ruta de perfil. El nombre/título del juego no está traducido al idioma IDE.

Comportamiento

Se leen los datos locales ya recibidos. La solicitud no abre el estado y no obliga al servidor a enviar una actualización. Después de la muerte, la transición del mapa o la eliminación de un objeto, los valores pueden cambiar entre dos llamadas.
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.

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

1. Mostrar texto después de iniciar sesión: script directo

Parámetros y flujo de ejecución:

No hay parámetros: se lee self.
La cadena vacía se maneja explícitamente; este no es el texto "0".

var text = UO.CharTitle();
if (Truth(text != ""))
{
    UO.Print(text);
}
else
{
    UO.Print("Text is unavailable");
}

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

2. Agregar texto al mensaje de registro: función de secuencia de comandos

Parámetros y flujo de ejecución:

Se lee su carácter, el valor se almacena como una línea.
El operador + une cadenas; Convert.ToString no es necesario para este resultado.

return  RunScenario();
 object? RunScenario()
{
    var text = UO.CharTitle();
    UO.Print("Player титул: " + text);
    return null;
}

3. Comparar dos instantáneas - clase de escenario

Parámetros y flujo de ejecución:

Ambas llamadas se refieren a self; UO.Wait establece la pausa 1000 ms.
La diferencia puede significar actualizar datos o abandonar el mundo. El ejemplo no cambia el nombre ni el título.

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 previous = UO.CharTitle();
        await Delay(1000);
        var current = UO.CharTitle();
        if (Truth(previous != current))
        {
            UO.Print("Updated text: " + current);
        }

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

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

Parámetros: Sin parámetros.

Resultado: dynamic / Any.

Durante la llamada:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CharacterTitle: bridge.CharacterTitle.

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

case "chartitle": return new InjectionValue(bridge.CharacterTitle);

UO.CharacterTitle

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

Firmas de C#

string UO.CharacterTitle();

Lee el título del personaje.

Parámetros

No hay parámetros.

Valor devuelto

string es un título conocido por el cliente. Una cadena vacía significa un valor vacío/desconocido o ningún objeto. Esto no es serial ni una ruta de perfil. El nombre/título del juego no está traducido al idioma IDE.

Comportamiento

Se leen los datos locales ya recibidos. La solicitud no abre el estado y no obliga al servidor a enviar una actualización. Después de la muerte, la transición del mapa o la eliminación de un objeto, los valores pueden cambiar entre dos llamadas.
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.

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

1. Mostrar texto después de iniciar sesión: script directo

Parámetros y flujo de ejecución:

No hay parámetros: se lee self.
La cadena vacía se maneja explícitamente; este no es el texto "0".

var text = UO.CharacterTitle();
if (Truth(text != ""))
{
    UO.Print(text);
}
else
{
    UO.Print("Text is unavailable");
}

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

2. Agregar texto al mensaje de registro: función de secuencia de comandos

Parámetros y flujo de ejecución:

Se lee su carácter, el valor se almacena como una línea.
El operador + une cadenas; Convert.ToString no es necesario para este resultado.

return  RunScenario();
 object? RunScenario()
{
    var text = UO.CharacterTitle();
    UO.Print("Player титул: " + text);
    return null;
}

3. Comparar dos instantáneas - clase de escenario

Parámetros y flujo de ejecución:

Ambas llamadas se refieren a self; UO.Wait establece la pausa 1000 ms.
La diferencia puede significar actualizar datos o abandonar el mundo. El ejemplo no cambia el nombre ni el título.

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 previous = UO.CharacterTitle();
        await Delay(1000);
        var current = UO.CharacterTitle();
        if (Truth(previous != current))
        {
            UO.Print("Updated text: " + current);
        }

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

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

Parámetros: Sin parámetros.

Resultado: string / String.

Durante la llamada:

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [CharacterTitle].
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CharacterTitle: bridge.CharacterTitle.

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.

() => bridge.CharacterTitle

Creación de API: Estas funciones registran la API. No se ejecutan de nuevo en cada llamada al comando.

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddText.

UO.ColdResist

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

Firmas de C#

int UO.ColdResist();

Lee el campo de resistencia del personaje actual: frío.

Parámetros

No hay parámetros.

Valor devuelto

int: valor de estado firmado, -32768..32767 en el modelo de cliente. El valor negativo se mantiene. 0 puede ser una resistencia real, falta de datos o un jugador perdido/destruido; GetResist también da 0 para un selector desconocido. Esto no es un límite bool, ID, de habilidad o resistencia. 1 significa un punto, no éxito.

Comportamiento

El comando no acepta argumentos. Utilice las firmas exactas anteriores.
La lectura del hilo del juego requiere Jugador.ColdResistance si el Jugador actual existe y no ha sido destruido; en caso contrario 0. El equipo no se clasifica, las bonificaciones no se recalculan, no se solicita el estado y no hay que esperar actualizaciones. Un fantasma presente no es igual a un Jugador destruido.
Los campos elementales vienen en formato extendido CharacterStatus (0x11), type >= 4. El comando en sí no verifica la época del servidor. El estado compacto/antiguo sin estos campos deja el caché anterior; El nuevo jugador es inicialmente 0. La resistencia al veneno no es una bandera Poisoned; Tampoco es una habilidad de resistencia a hechizos.
CharacterStatus verifica el cuerpo requerido antes de cambiar el nombre, la salud y las características propias, luego traduce cada palabra de resistencia a un Int16 firmado. Un cuerpo obligatorio recortado no modifica los datos anteriores. La cola opcional type 6 conserva las mismas reglas; Los comandos de resistencia no leen los límites máximos.
Cada llamada lee los datos locales de nuevo. La variable almacena la instantánea; las lecturas individuales pueden recibir diferentes actualizaciones del servidor. Un resultado distinto de cero no prueba la conexión. Cero puede ser un valor o ningún dato.
Estas funciones registran la API. No se ejecutan de nuevo en cada llamada al 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.

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

1. Imprimir valor guardado - script directo

Parámetros y flujo de ejecución:

El valor almacena el resultado de una llamada. Convertir.ToString formatea el número del registro. No hay argumentos: puedes leer tu propio personaje.

var value = UO.ColdResist();
UO.Print("ColdResistance: " + Convert.ToString(value));

2. Comparar dos imágenes - función de script

Parámetros y flujo de ejecución:

Entre antes y después hay UO.Wait(500) milisegundos; la diferencia puede ser negativa. Es posible que se pierdan actualizaciones provisionales. La pausa se refiere al ejemplo, no al retraso API.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.ColdResist();
    await Delay(500);
    var after = UO.ColdResist();
    var difference = after - before;
    UO.Print("Resistance change: " + Convert.ToString(difference));
    return null;
}

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

3. Función de prueba de resistencia mínima completa: clase de script

Parámetros y flujo de ejecución:

mínimo=50 es un ejemplo de requisito, no de límite de clientes. ResistanceAtLeast rechaza al jugador que falta, lee un valor y devuelve bool: true o false si el valor >= mínimo. La resistencia en sí no es bool. La función se declara completamente a continuació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()
    {
        if (Truth(Truth(ResistanceAtLeast(50)) == true))
        {
            UO.Print("Local resistance requirement met");
        }
        else
        {
            UO.Print("Requirement not met or no player");
        }

        return null;
    }

    dynamic ResistanceAtLeast(dynamic minimum)
    {
        if (Truth(UO.Self() == 0))
        {
            return false;
        }

        var value = UO.ColdResist();
        return value >= minimum;
    }

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

Parámetros: Sin parámetros.

Resultado: int / Integer.

Durante la llamada:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.ColdResistance: bridge.ColdResistance.

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

case "coldresist": return new InjectionValue(bridge.ColdResistance);

UO.Dead

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

Firmas de C#

int UO.Dead();
int UO.Dead(object? id);

Comprueba la muerte del personaje.

Parámetros

id: objeto opcional en los formularios que se muestran: serial por número/cadena hexadecimal, self, lasttarget o nombre registrado AddObject. Esto no es type. Sin argumentos, lea self. El texto desconocido en algunos formularios provoca un error de conversión; Verifique el nombre antes de llamar.

Valor devuelto

Bandera numérica int: 1 (condición cumplida), 0 (condición no cumplida). Esta es una bandera numérica: en C# verifique el resultado! = 0 o resultado == 0. Comparación directa de int con true/false y si (resultado) no está permitido. 1 - mobile tiene IsDead, 0 no tiene signo o mobile está ausente. HP=0 por sí solo no significa muerte.

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

Lee el modelo local: no abre el destino, no solicita el estado, no cambia la bandera y no envía el paquete. Un objeto destruido se considera perdido incluso antes de que la entrada se elimine del diccionario.
El resultado es una lectura separada. El mundo puede cambiar entre Exists y el próximo desafío; varias consultas no forman una instantánea atómica.

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

1. Comprueba tu propio estado - guión directo

Parámetros y flujo de ejecución:

Los paréntesis vacíos dicen self. activo guarda el resultado una vez; true y false definen dos ramas. Print solo muestra un mensaje de ejemplo.

var active = UO.Dead();
if (Truth(Truth(active) == true))
{
    UO.Print("State is active");
}
else
{
    UO.Print("State is inactive or unavailable");
}

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

2. Objeto seleccionado y función completa ReadState - función de script

Parámetros y flujo de ejecución:

lasttarget – objeto previamente seleccionado. Exists comprueba su presencia. obj es el único parámetro ReadState; la función devuelve el resultado del comando sin modificación. Su definición está incluida en el código copiado.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Exists("lasttarget")))
    {
        var observed = ReadState("lasttarget");
        UO.Print("State 1/0: " + Convert.ToString(observed));
    }

    return null;
}

dynamic ReadState(dynamic obj)
{
    return UO.Dead(obj);
}

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

3. Observe un cambio en medio segundo - clase de script

Parámetros y flujo de ejecución:

Dos llamadas sin argumentos leen self, UO.Wait(500) establece 500 milisegundos. Se comparan dos imágenes; se pueden omitir las transiciones intermedias. No hay una espera interminable.

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

    async public Task<object?> RunScenarioAsync()
    {
        var before = UO.Dead();
        await Delay(500);
        var after = UO.Dead();
        if (Truth(before != after))
        {
            UO.Print("State changed: " + Convert.ToString(before) + " -> " + Convert.ToString(after));
        }

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

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

Parámetros: Sin parámetros.

Resultado: int / Integer.

Durante la llamada:

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

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

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

`UO.Dead(id)` — `UO.Dead(Any)`

Parámetros: id (Any)

Resultado: int / Integer.

Durante la llamada:

InjectionScript.Runtime.InjectionApiUO.Dead.
InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(id).
InjectionScript.Runtime.InjectionApiUO.Dead: Dead().
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.IsDead: bridge.IsDead(serial).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self: bridge.Self.

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

public int Dead(InjectionValue id)

        {

            int serial = GetObject(id);

            if (serial == bridge.Self)

                return Dead();

            return serial > 0 ? bridge.IsDead(serial) : 0;

        }

UO.Dex

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

Firmas de C#

int UO.Dex();

Lee la agilidad actual (Dexterity, DEX) del personaje.

Parámetros

No hay parámetros.

Valor devuelto

int — puntos de estadísticas actuales, 0...65535 en el modelo del cliente; no porcentaje, ID, habilidad, modo de bloqueo o bool. 0 también significa carácter faltante/eliminado u objeto inaccesible. Compare con el requisito numérico, no == true. Este no es un límite de estadísticas ni un valor base garantizado sin modificadores.

Comportamiento

El comando no acepta argumentos. Utilice las firmas exactas anteriores.
Lee Player.Dexterity si Player existe y no ha sido destruido; en caso contrario 0. Un personaje muerto presente no es un objeto eliminado. La estadística no se calcula a partir de HP, maná o resistencia.
GetStr/GetInt/GetDex acepta ObjID. Los datos de PlayerMobile solo están disponibles para self; para otro serial - 0, incluso para mobile cargado. Las características de otra persona no se sustituyen ni se adivinan.
Invoca lecturas en la transmisión del juego con la capacidad de cancelar la espera mediante script. No consulta el estado, no abre el destino, no envía un paquete, no cambia la característica y no agrega retraso.
Cada llamada lee los datos locales de nuevo. La variable almacena la instantánea; las lecturas individuales pueden recibir diferentes actualizaciones del servidor. Un resultado distinto de cero no prueba la conexión. Cero puede ser un valor o ningún dato.
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.Dex(), UO.Dexterity(), UO.GetDex(), UO.GetDexterity().

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

1. Leer y mostrar puntos: guión directo

Parámetros y flujo de ejecución:

el valor almacena el resultado numérico; Convertir.ToString simplemente lo formatea para la revista. No hay argumentos ni acciones de personajes.

var value = UO.Dex();
UO.Print("Dexterity: " + Convert.ToString(value));

2. Comparar dos imágenes - función de script

Parámetros y flujo de ejecución:

antes y después separados 1000 ms; UO.Wait agregado al ejemplo. cambio=después-antes puede ser positivo, cero o negativo. Por sí solo, no distingue entre todas las actualizaciones intermedias y la salida del mundo.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.Dex();
    await Delay(1000);
    var after = UO.Dex();
    var change = after - before;
    UO.Print("Change: " + Convert.ToString(change));
    return null;
}

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

3. Función de validación de requisitos completa: clase de secuencia de comandos

Parámetros y flujo de ejecución:

mínimo=80 es un ejemplo de requisito, no de límite de clientes. AttributeAtLeast(mínimo) rechaza el carácter faltante, lee la característica una vez y devuelve bool: true o false si >= mínimo. El significado lógico lo da la comparación, no la característica en sí.

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(AttributeAtLeast(80)) == true))
        {
            UO.Print("Requirement met");
        }
        else
        {
            UO.Print("Requirement not met or no player");
        }

        return null;
    }

    dynamic AttributeAtLeast(dynamic minimum)
    {
        if (Truth(UO.Self() == 0))
        {
            return false;
        }

        var value = UO.Dex();
        return value >= minimum;
    }

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

Parámetros: Sin parámetros.

Resultado: int / Integer.

Durante la llamada:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Dexterity: bridge.Dexterity.

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

case "dex": return new InjectionValue(bridge.Dexterity);

UO.Dexterity

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

Firmas de C#

int UO.Dexterity();

Lee la agilidad actual (Dexterity, DEX) del personaje.

Parámetros

No hay parámetros.

Valor devuelto

int — puntos de estadísticas actuales, 0...65535 en el modelo del cliente; no porcentaje, ID, habilidad, modo de bloqueo o bool. 0 también significa carácter faltante/eliminado u objeto inaccesible. Compare con el requisito numérico, no == true. Este no es un límite de estadísticas ni un valor base garantizado sin modificadores.

Comportamiento

El comando no acepta argumentos. Utilice las firmas exactas anteriores.
Lee Player.Dexterity si Player existe y no ha sido destruido; en caso contrario 0. Un personaje muerto presente no es un objeto eliminado. La estadística no se calcula a partir de HP, maná o resistencia.
GetStr/GetInt/GetDex acepta ObjID. Los datos de PlayerMobile solo están disponibles para self; para otro serial - 0, incluso para mobile cargado. Las características de otra persona no se sustituyen ni se adivinan.
Invoca lecturas en la transmisión del juego con la capacidad de cancelar la espera mediante script. No consulta el estado, no abre el destino, no envía un paquete, no cambia la característica y no agrega retraso.
Cada llamada lee los datos locales de nuevo. La variable almacena la instantánea; las lecturas individuales pueden recibir diferentes actualizaciones del servidor. Un resultado distinto de cero no prueba la conexión. Cero puede ser un valor o ningún dato.
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.Dex(), UO.Dexterity(), UO.GetDex(), UO.GetDexterity().

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

1. Leer y mostrar puntos: guión directo

Parámetros y flujo de ejecución:

el valor almacena el resultado numérico; Convertir.ToString simplemente lo formatea para la revista. No hay argumentos ni acciones de personajes.

var value = UO.Dexterity();
UO.Print("Dexterity: " + Convert.ToString(value));

2. Comparar dos imágenes - función de script

Parámetros y flujo de ejecución:

antes y después separados 1000 ms; UO.Wait agregado al ejemplo. cambio=después-antes puede ser positivo, cero o negativo. Por sí solo, no distingue entre todas las actualizaciones intermedias y la salida del mundo.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.Dexterity();
    await Delay(1000);
    var after = UO.Dexterity();
    var change = after - before;
    UO.Print("Change: " + Convert.ToString(change));
    return null;
}

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

3. Función de validación de requisitos completa: clase de secuencia de comandos

Parámetros y flujo de ejecución:

mínimo=80 es un ejemplo de requisito, no de límite de clientes. AttributeAtLeast(mínimo) rechaza el carácter faltante, lee la característica una vez y devuelve bool: true o false si >= mínimo. El significado lógico lo da la comparación, no la característica en sí.

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(AttributeAtLeast(80)) == true))
        {
            UO.Print("Requirement met");
        }
        else
        {
            UO.Print("Requirement not met or no player");
        }

        return null;
    }

    dynamic AttributeAtLeast(dynamic minimum)
    {
        if (Truth(UO.Self() == 0))
        {
            return false;
        }

        var value = UO.Dexterity();
        return value >= minimum;
    }

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

Parámetros: Sin parámetros.

Resultado: int / Integer.

Durante la llamada:

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.

() => bridge.Dexterity

Creación de API: Estas funciones registran la API. No se ejecutan de nuevo en cada llamada al comando.

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddInteger.

UO.Disarm

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

Firmas de C#

int UO.Disarm();

Elimina armas y escudos de las manos: capas 1 y 2. No afecta la ropa.

Parámetros

No hay parámetros.

Valor devuelto

Bandera numérica int: 1 (condición cumplida) - operación local aceptada, 0 (condición no cumplida) - negativa. Esto no es una confirmación del servidor, ni ID, ni una cantidad. El servidor puede fallar más tarde; Verifique el equipo real después de responder.

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

Necesita elementos cargados y arrastre con las manos libres. Cuando se retira, se requiere la mochila self real: la GrabBag de repuesto no se utiliza. Se rechazan los artículos desconocidos, destruidos o inadecuados. Los artículos de otras personas no se pueden eliminar mediante UnequipItems. Un conjunto no es una transacción atómica.
EquipItems/UnequipItems aplica DressSpeed después de la operación aceptada antes del siguiente elemento; Disarm/Undress - después de cada capa ocupada. El retiro también respeta DropDelay cuando se acepta el acarreo. Las mismas configuraciones de otros tiempos de ejecución no cambian; La aceleración no anula las limitaciones del servidor.
Un formulario de llamada incorrecto, un nombre de capa desconocido o un valor que no se puede convertir en un número pueden provocar un error de secuencia de comandos en lugar de 0. La instantánea del equipo solo contiene datos que ya se han cargado. En el asistente, ChangeAndConfirm capa=1 es la mano derecha: por otra cosa, pasa su capa real.
Para una matriz, 1 significa que se aceptan todas las operaciones enumeradas; en caso de rechazo, se devuelve 0. Los elementos restantes aún se procesan, no hay reversión. Una matriz vacía produce 1 sin acción. Disarm/Undress dé 1 también cuando las capas requeridas ya estén vacías; el fallo parcial da 0.
UO.EquipItems · UO.UnequipItems · UO.DressSpeed · UO.DropDelay · UO.ObjAtLayerEx

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

1. Disarm - Un elemento o capa seleccionado - script directo

Parámetros y flujo de ejecución:

Primero, selecciona el elemento apropiado en el juego: lasttarget - es ID. En el ejemplo Equip/WearItem, la capa 1 requiere un arma de mano izquierda. Unequip(1) quita la mano derecha; Disarm/Undress funcionan con sus propias capas fijas. No hay repeticiones automáticas después de un rechazo.

return UO.Disarm();

2. Disarm - Dos elementos y guardados ID - función de script

Parámetros y flujo de ejecución:

Para equipar, 0x0F5E es un ejemplo de espada, 0x1B76 es un ejemplo de escudo. FindType los busca entre los elementos cargados de la mochila, ASC convierte el hexadecimal devuelto-ID. Para eliminarlas se leen las propias capas actuales. Si el elemento requerido no está disponible, el script finaliza. La matriz almacena dos ID; Cada artículo se transfiere en su totalidad.

return  RunScenario();
 object? RunScenario()
{
    var first = UO.ObjAtLayerEx(1, UO.Self());
    var second = UO.ObjAtLayerEx(2, UO.Self());
    if (Truth(first == 0) || Truth(second == 0))
    {
        return 0;
    }

    UO.AddObject("saved_first", first);
    UO.AddObject("saved_second", second);
    return UO.Disarm();
    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. Disarm - Función completa con espera limitada - clase de script

Parámetros y flujo de ejecución:

ChangeAndConfirm ejecuta el comando una vez. Luego verifica el estado real hasta 20 veces con una pausa de 100 ms. 1 - la verificación vio el estado esperado, 0 - falla o espera vencida. Este es el resultado de nuestro asistente, no un nuevo comando integrado. Llamar a la operación en sí también puede llevar tiempo.

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()
    {
        return ChangeAndConfirm();
        return null;
    }

    dynamic ChangeAndConfirm()
    {
        if (!(Truth(UO.Disarm())))
        {
            return 0;
        }

        dynamic[] layers = new dynamic[checked((int)(1) + 1)];
        layers[0] = 1;
        layers[1] = 2;
        for (int attempt = (int)(1); attempt <= 20; attempt += (int)(1))
        {
            dynamic empty = true;
            for (int i = (int)(0); i <= ArrayLength(layers) - 1; i += (int)(1))
            {
                if (Truth(UO.ObjAtLayerEx(layers[i], UO.Self()) != 0))
                {
                    empty = false;
                }
            }

            if (Truth(empty))
            {
                return 1;
            }

            UO.Wait(100);
        }

        return 0;
    }

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

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

Parámetros: Sin parámetros.

Resultado: int / Integer.

Durante la llamada:

InjectionScript.Runtime.InjectionApiUO.Disarm.
InjectionScript.Runtime.InjectionApiUO.Unequip: Unequip(weaponLayers, "Weapons disarmed.").

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

public int Disarm()

            => Unequip(weaponLayers, "Weapons disarmed.");

UO.Dismount

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

Firmas de C#

void UO.Dismount();

Solicita desmontar si el personaje está actualmente montado.

Parámetros

No hay parámetros.

Valor devuelto

void: sin valor de retorno. Llame como una línea separada, no compare el resultado con 1/true. Verifique la capa 25 después de que el servidor responda.

Comportamiento

El comando envía una solicitud para utilizar el objeto de protocolo UO (0x06), sin emulación de mouse. Omite el controlador común de clic double de la interfaz: en modo guerra, la solicitud no es reemplazada por un ataque.
El estado de la montura se lee desde la capa 25. Cambia después de los datos del servidor; regresar del comando no confirma la finalización del aterrizaje/desmontaje.
Las solicitudes repetidas de montaje/desmontaje se fusionan temporalmente: no se envía ninguna solicitud nueva hasta que hayan pasado un cambio de capa, un cambio de carácter o 5 segundos. Esto protege contra la duplicación entre scripts.
Si el personaje está ausente, fuera del juego o por un personaje muerto, la solicitud no se envía. Las reglas finales de propiedad, disponibilidad y asientos las determina el servidor.
Si la capa 25 está vacía, no aparece ningún mensaje y Paperdoll no se abre. Un artículo de barco de servicio con graphic 0x3E96 no cuenta como una montura normal para ese equipo.
UO.Exec("dismount") llama al mismo controlador y utiliza la misma protección de reproducción. No puede pasar parámetros en la línea de desmontaje: un argumento adicional provoca un error y no envía la solicitud.

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

1. Solicitar desmontaje - script directo

Parámetros y flujo de ejecución:

No hay parámetros. Tampoco hay valor de retorno.

UO.Dismount();

2. Verificar la presencia del elemento montado antes de la solicitud: función de script

Parámetros y flujo de ejecución:

montado: ID del elemento de capa, no el objetivo para llamar a Mount nuevamente. Dismount no toma argumentos.

return  RunScenario();
 object? RunScenario()
{
    var ridden = UO.ObjAtLayer(25);
    if (Truth(ridden == 0))
    {
        UO.Print("No loaded mount layer");
        return null;
    }

    UO.Print("Mounted item ID: " + Convert.ToString(ridden));
    UO.Dismount();
    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 de espera de capa vacía completa: clase de secuencia de comandos

Parámetros y flujo de ejecución:

El ayudante devuelve true si la capa ya está vacía o quedó vacía dentro de lo esperado. No envía más de una solicitud.
Esta es una verificación del estado del cliente después de la respuesta del servidor, no del valor de retorno de UO.Dismount.

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 dismounted = await TryDismount();
        UO.Print("Mount layer empty: " + Convert.ToString(dismounted));
        return null;
    }

    async Task<dynamic> TryDismount()
    {
        if (Truth(UO.ObjAtLayer(25) == 0))
        {
            return true;
        }

        UO.Dismount();
        var attempts = 0;
        while (Truth(attempts < 20))
        {
            if (Truth(UO.ObjAtLayer(25) == 0))
            {
                return true;
            }

            await Delay(50);
            attempts = attempts + 1;
        }

        return false;
    }

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

Parámetros: Sin parámetros.

Resultado: void / Unit.

Durante la llamada:

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

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

case "dismount": bridge.Dismount(); break;

UO.Dress

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

Firmas de C#

void UO.Dress(object? name);

Restaura un conjunto de ropa con nombre previamente guardado.

Parámetros

name: nombre de cadena del conjunto, como "viaje" o "batalla". Los nombres no distinguen entre mayúsculas y minúsculas. Los conjuntos de ropa y armas se almacenan por separado: se permite el mismo nombre en ambos. Esto no es una cosa ID ni un nombre de archivo. Sólo SetDress permite la ausencia de un nombre: entonces se registra un conjunto separado para DressSavedSet/EquipDressSet.

Valor devuelto

void - sin valor. Llame en una línea separada; no asigne el resultado ni lo compare con true. Guardar y eliminar cambia la entrada, no el equipo.

Comportamiento

Ropa: capas 3,4,5,6,7,8,10,12,13,14,17,18,19,20,22,23,24. Armas: 1 y 2 únicamente. Pelo, barba, mochila, animal y banco no están incluidos en estos sets.
Los elementos específicos serial ya cargados se registran en sus propias capas. Guardar el mismo nombre nuevamente reemplaza la entrada. Las capas vacías también tienen sentido: cuando se restauren, la capa ocupada correspondiente se liberará en su propia mochila. Por lo tanto, un conjunto guardado completamente vacío elimina elementos de sus capas.
El conjunto se almacena en el estado de tiempo de ejecución. La llamada en sí no crea un archivo y no garantiza que el conjunto se transfiera a otro perfil o a un nuevo tiempo de ejecución. Primero, guarde el conjunto deseado en su estado usado. Cargar/guardar el estado general del cliente es un mecanismo separado.
Se omite una coincidencia exacta entre el ID actual y el guardado, sin volver a utilizarlo o generarlo. Un elemento faltante no se reemplaza por un type similar. El fracaso de una operación no anula las exitosas ni interfiere con los intentos de otras; No hay reversión automática. Necesita conexión y cosas cargadas. Cuando se retira, se utiliza una mochila real.
UO.Set("equipfordress", 0) selecciona la solicitud para utilizar el elemento (modo inicial); valor distinto de cero - recogida/equipamiento. La capa portátil deseada se comprueba en ambos modos. Un artículo ya usado no se puede cambiar mediante un uso repetido. DressSpeed es válido después de la solicitud aceptada, el retiro respeta adicionalmente DropDelay.
Dress y Arm devuelven void incluso en caso de falla. El mensaje de que las solicitudes han sido aceptadas no significa confirmación por parte del servidor. Para una continuación que depende de la colocación, verifique las capas reales con expectativas limitadas.
UO.SetDress · UO.Dress · UO.DressSavedSet · UO.SetArm · UO.Arm · UO.DressSpeed

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

1. Uso directo - guión directo

Parámetros y flujo de ejecución:

El conjunto requerido debe guardarse anteriormente en el mismo estado de ejecución. No llame a SetDress/SetArm justo antes de cada restauración: esto sobrescribirá el objetivo con los elementos actuales.

UO.Dress("travel");

2. Nombres y modo de consulta: función de secuencia de comandos

Parámetros y flujo de ejecución:

Un equipo distinto de cero selecciona recoger/equipar; 350 — milisegundos DressSpeed. Estas configuraciones permanecen en tiempo de ejecución después del ejemplo. La retirada y colocación la decide el servidor.

return  RunScenario();
 object? RunScenario()
{
    UO.Set("equipfordress", 1);
    UO.DressSpeed(350);
    UO.Dress("travel");
    return null;
}

3. Script auxiliar completo - Clase de script

Parámetros y flujo de ejecución:

lasttarget: ID cosas que deberían incluirse en un conjunto previamente guardado. La capa de control 3 significa zapatos, 1 significa mano derecha. AwaitSlot compensa hasta 20 comprobaciones con una pausa de 100 ms y no repite el comando. Esto confirma sólo el elemento seleccionado, no todo el conjunto.

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 expected = Asc(UO.GetSerial("lasttarget"), 0);
        if (Truth(expected == 0))
        {
            return 0;
        }

        UO.Dress("travel");
        return AwaitSlot(3, expected);
        return null;
    }

    dynamic AwaitSlot(dynamic layer, dynamic expected)
    {
        for (int attempt = (int)(1); attempt <= 20; attempt += (int)(1))
        {
            if (Truth(UO.ObjAtLayerEx(layer, UO.Self()) == expected))
            {
                return 1;
            }

            UO.Wait(100);
        }

        return 0;
    }

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

    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.Dress(name)` — `UO.Dress(String)`

Parámetros: name (String)

Resultado: void / Unit.

Durante la llamada:

InjectionScript.Runtime.InjectionApiUO.Dress.
InjectionScript.Runtime.InjectionApiUO.Equip: Equip(name, dressSets, dressLayers, "Clothing set requests processed.", "No clothing set with setdress.").

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

public void Dress(string name)

            => Equip(name, dressSets, dressLayers, "Clothing set requests processed.", "No clothing set with setdress.");

UO.DressSavedSet

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

Firmas de C#

dynamic UO.DressSavedSet();

Restaura un conjunto de ropa guardada llamando a UO.SetDress() sin nombre.

Parámetros

No hay parámetros.

Valor devuelto

De hecho, indicador numérico int: 1 (condición cumplida): todas las solicitudes necesarias se aceptan localmente o las capas necesarias ya coinciden; 0 (condición no cumplida): no se realizó marcación, no hubo conexión o al menos una solicitud fue rechazada. ¿Registro object? permite esto int. Esto no es ID, la cantidad de artículos usados o la confirmación del servidor.

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

Ropa: capas 3,4,5,6,7,8,10,12,13,14,17,18,19,20,22,23,24. Armas: 1 y 2 únicamente. Pelo, barba, mochila, animal y banco no están incluidos en estos sets.
Los elementos específicos serial ya cargados se registran en sus propias capas. Guardar el mismo nombre nuevamente reemplaza la entrada. Las capas vacías también tienen sentido: cuando se restauren, la capa ocupada correspondiente se liberará en su propia mochila. Por lo tanto, un conjunto guardado completamente vacío elimina elementos de sus capas.
El conjunto se almacena en el estado de tiempo de ejecución. La llamada en sí no crea un archivo y no garantiza que el conjunto se transfiera a otro perfil o a un nuevo tiempo de ejecución. Primero, guarde el conjunto deseado en su estado usado. Cargar/guardar el estado general del cliente es un mecanismo separado.
Se omite una coincidencia exacta entre el ID actual y el guardado, sin volver a utilizarlo o generarlo. Un elemento faltante no se reemplaza por un type similar. El fracaso de una operación no anula las exitosas ni interfiere con los intentos de otras; No hay reversión automática. Necesita conexión y cosas cargadas. Cuando se retira, se utiliza una mochila real.
UO.Set("equipfordress", 0) selecciona la solicitud para utilizar el elemento (modo inicial); valor distinto de cero - recogida/equipamiento. La capa portátil deseada se comprueba en ambos modos. Un artículo ya usado no se puede cambiar mediante un uso repetido. DressSpeed es válido después de la solicitud aceptada, el retiro respeta adicionalmente DropDelay.
Dress y Arm devuelven null incluso en caso de falla. El mensaje de que las solicitudes han sido aceptadas no significa confirmación por parte del servidor. Para una continuación que depende de la colocación, verifique las capas reales con expectativas limitadas.
UO.SetDress · UO.Dress · UO.DressSavedSet · UO.SetArm · UO.Arm · UO.DressSpeed

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

1. Uso directo - guión directo

Parámetros y flujo de ejecución:

El conjunto requerido debe guardarse anteriormente en el mismo estado de ejecución. No llame a SetDress/SetArm justo antes de cada restauración: esto sobrescribirá el objetivo con los elementos actuales.

return UO.DressSavedSet();

2. Nombres y modo de consulta: función de secuencia de comandos

Parámetros y flujo de ejecución:

Un equipo distinto de cero selecciona recoger/equipar; 350 — milisegundos DressSpeed. Estas configuraciones permanecen en tiempo de ejecución después del ejemplo. La retirada y colocación la decide el servidor.

return  RunScenario();
 object? RunScenario()
{
    UO.Set("equipfordress", 1);
    UO.DressSpeed(350);
    return UO.DressSavedSet();
    return null;
}

3. Script auxiliar completo - Clase de script

Parámetros y flujo de ejecución:

lasttarget: ID cosas que deberían incluirse en un conjunto previamente guardado. La capa de control 3 significa zapatos, 1 significa mano derecha. AwaitSlot compensa hasta 20 comprobaciones con una pausa de 100 ms y no repite el comando. Esto confirma sólo el elemento seleccionado, no todo el conjunto.

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 expected = Asc(UO.GetSerial("lasttarget"), 0);
        if (Truth(expected == 0))
        {
            return 0;
        }

        if (!(Truth(UO.DressSavedSet())))
        {
            return 0;
        }

        return AwaitSlot(3, expected);
        return null;
    }

    dynamic AwaitSlot(dynamic layer, dynamic expected)
    {
        for (int attempt = (int)(1); attempt <= 20; attempt += (int)(1))
        {
            if (Truth(UO.ObjAtLayerEx(layer, UO.Self()) == expected))
            {
                return 1;
            }

            UO.Wait(100);
        }

        return 0;
    }

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

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

Parámetros: Sin parámetros.

Resultado: dynamic / Any.

Durante la llamada:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
InjectionScript.Runtime.InjectionApiUO.Equip: Equip("__stealth_saved_set__", dressSets, dressLayers, "Clothing set requests processed.", "No clothing set with setdress.").

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

case "dresssavedset":

                case "equipdressset": return new InjectionValue(Equip("__stealth_saved_set__", dressSets, dressLayers, "Clothing set requests processed.", "No clothing set with setdress."));

UO.DressSpeed

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

Firmas de C#

dynamic UO.DressSpeed();
dynamic UO.DressSpeed(object? value);

Lee o establece la pausa entre las operaciones de vestirse/desvestirse en el tiempo de ejecución actual. Ayuda a evitar enviar una serie de acciones demasiado rápido para las reglas del servidor.

Parámetros

value: milisegundos opcionales. Sin argumento - lectura; con argumento el valor se limita a 10..10000. El valor inicial del tiempo de ejecución puede ser 0 si aún no se ha especificado el retraso; No puedes escribir 0 usando este comando.

Valor devuelto

Sin argumento: int, milisegundos actuales. Con argumento: null, sin valor de retorno; luego lea UO.DressSpeed() por separado. Esto no es bool.

Comportamiento

EquipItems/UnequipItems aplica DressSpeed después de la operación aceptada antes del siguiente elemento; Disarm/Undress - después de cada capa ocupada. El retiro también respeta DropDelay cuando se acepta el acarreo. Las mismas configuraciones de otros tiempos de ejecución no cambian; La aceleración no anula las limitaciones del servidor.
UO.EquipItems · UO.UnequipItems · UO.DressSpeed · UO.DropDelay · UO.ObjAtLayerEx

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

1. DressSpeed - 1 - guión directo

Parámetros y flujo de ejecución:

Lea la pausa actual y seleccione el mínimo para el siguiente conjunto; 0 significa un retraso que aún no se ha establecido.

var delay = UO.DressSpeed();
if (Truth(delay < 350))
{
    UO.DressSpeed(350);
}
return UO.DressSpeed();

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

2. DressSpeed — 2 — función de secuencia de comandos

Parámetros y flujo de ejecución:

Configure 350 ms y verifique el valor almacenado por separado. No puede asignar el resultado de un definidor a una variable: el definidor devuelve Unidad.

return  RunScenario();
 object? RunScenario()
{
    UO.DressSpeed(350);
    return UO.DressSpeed();
    return null;
}

3. DressSpeed - 3 - clase de escenario

Parámetros y flujo de ejecución:

ConfigureDressDelay acepta la configuración del script. 15000 está limitado a 10000 ms; El asistente devuelve los milisegundos guardados reales.

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()
    {
        return ConfigureDressDelay(15000);
        return null;
    }

    dynamic ConfigureDressDelay(dynamic requested)
    {
        UO.DressSpeed(requested);
        return UO.DressSpeed();
    }
}

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

Parámetros: Sin parámetros.

Resultado: dynamic / Any.

Durante la llamada:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
InjectionScript.Runtime.InjectionApiUO.SetDressSpeed: SetDressSpeed(Arg(0)).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).

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

case "dressspeed":

                    if (arguments.Length > 0) { SetDressSpeed(Arg(0)); return InjectionValue.Unit; }

                    return new InjectionValue(state.DressSpeed);

`UO.DressSpeed(value)` — `UO.DressSpeed(Any)`

Parámetros: value (Any)

Resultado: dynamic / Any.

Durante la llamada:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
InjectionScript.Runtime.InjectionApiUO.SetDressSpeed: SetDressSpeed(Arg(0)).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).

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

case "dressspeed":

                    if (arguments.Length > 0) { SetDressSpeed(Arg(0)); return InjectionValue.Unit; }

                    return new InjectionValue(state.DressSpeed);

UO.EnergyResist

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

Firmas de C#

int UO.EnergyResist();

Lee el campo de resistencia del personaje actual: energía.

Parámetros

No hay parámetros.

Valor devuelto

int: valor de estado firmado, -32768..32767 en el modelo de cliente. El valor negativo se mantiene. 0 puede ser una resistencia real, falta de datos o un jugador perdido/destruido; GetResist también da 0 para un selector desconocido. Esto no es un límite bool, ID, de habilidad o resistencia. 1 significa un punto, no éxito.

Comportamiento

El comando no acepta argumentos. Utilice las firmas exactas anteriores.
La lectura del hilo del juego requiere Jugador.EnergyResistance si el Jugador actual existe y no ha sido destruido; en caso contrario 0. El equipo no se clasifica, las bonificaciones no se recalculan, no se solicita el estado y no hay que esperar actualizaciones. Un fantasma presente no es igual a un Jugador destruido.
Los campos elementales vienen en formato extendido CharacterStatus (0x11), type >= 4. El comando en sí no verifica la época del servidor. El estado compacto/antiguo sin estos campos deja el caché anterior; El nuevo jugador es inicialmente 0. La resistencia al veneno no es una bandera Poisoned; Tampoco es una habilidad de resistencia a hechizos.
CharacterStatus verifica el cuerpo requerido antes de cambiar el nombre, la salud y las características propias, luego traduce cada palabra de resistencia a un Int16 firmado. Un cuerpo obligatorio recortado no modifica los datos anteriores. La cola opcional type 6 conserva las mismas reglas; Los comandos de resistencia no leen los límites máximos.
Cada llamada lee los datos locales de nuevo. La variable almacena la instantánea; las lecturas individuales pueden recibir diferentes actualizaciones del servidor. Un resultado distinto de cero no prueba la conexión. Cero puede ser un valor o ningún dato.
Estas funciones registran la API. No se ejecutan de nuevo en cada llamada al 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.

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

1. Imprimir valor guardado - script directo

Parámetros y flujo de ejecución:

El valor almacena el resultado de una llamada. Convertir.ToString formatea el número del registro. No hay argumentos: puedes leer tu propio personaje.

var value = UO.EnergyResist();
UO.Print("EnergyResistance: " + Convert.ToString(value));

2. Comparar dos imágenes - función de script

Parámetros y flujo de ejecución:

Entre antes y después hay UO.Wait(500) milisegundos; la diferencia puede ser negativa. Es posible que se pierdan actualizaciones provisionales. La pausa se refiere al ejemplo, no al retraso API.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.EnergyResist();
    await Delay(500);
    var after = UO.EnergyResist();
    var difference = after - before;
    UO.Print("Resistance change: " + Convert.ToString(difference));
    return null;
}

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

3. Función de prueba de resistencia mínima completa: clase de script

Parámetros y flujo de ejecución:

mínimo=50 es un ejemplo de requisito, no de límite de clientes. ResistanceAtLeast rechaza al jugador que falta, lee un valor y devuelve bool: true o false si el valor >= mínimo. La resistencia en sí no es bool. La función se declara completamente a continuació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()
    {
        if (Truth(Truth(ResistanceAtLeast(50)) == true))
        {
            UO.Print("Local resistance requirement met");
        }
        else
        {
            UO.Print("Requirement not met or no player");
        }

        return null;
    }

    dynamic ResistanceAtLeast(dynamic minimum)
    {
        if (Truth(UO.Self() == 0))
        {
            return false;
        }

        var value = UO.EnergyResist();
        return value >= minimum;
    }

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

Parámetros: Sin parámetros.

Resultado: int / Integer.

Durante la llamada:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.EnergyResistance: bridge.EnergyResistance.

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

case "energyresist": return new InjectionValue(bridge.EnergyResistance);

UO.Equip

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

Firmas de C#

int UO.Equip(object? layer, object? id);

Equipa el elemento seleccionado en la capa especificada de tu personaje.

Parámetros

layer - Número de capa, por ejemplo 1 - mano derecha, 2 - izquierda. Equip y Unequip también aceptan un nombre de capa, como "Rhand". WearItem usa una capa numérica. La capa debe coincidir con la capa portátil del artículo; no es graphic ni ID.
id - ID del elemento específico cargado: entero, cadena hexadecimal, "lasttarget" o nombre AddObject. Esto no es type. Ejemplo con 0x0F5E primero buscando la espada de ese graphic y consiguiéndola con ID.

Valor devuelto

Bandera numérica int: 1 (condición cumplida) - operación local aceptada, 0 (condición no cumplida) - negativa. Esto no es una confirmación del servidor, ni ID, ni una cantidad. El servidor puede fallar más tarde; Verifique el equipo real después de responder.

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

Necesita elementos cargados y arrastre con las manos libres. Cuando se retira, se requiere la mochila self real: la GrabBag de repuesto no se utiliza. Se rechazan los artículos desconocidos, destruidos o inadecuados. Los artículos de otras personas no se pueden eliminar mediante UnequipItems. Un conjunto no es una transacción atómica.
EquipItems/UnequipItems aplica DressSpeed después de la operación aceptada antes del siguiente elemento; Disarm/Undress - después de cada capa ocupada. El retiro también respeta DropDelay cuando se acepta el acarreo. Las mismas configuraciones de otros tiempos de ejecución no cambian; La aceleración no anula las limitaciones del servidor.
Un formulario de llamada incorrecto, un nombre de capa desconocido o un valor que no se puede convertir en un número pueden provocar un error de secuencia de comandos en lugar de 0. La instantánea del equipo solo contiene datos que ya se han cargado. En el asistente, ChangeAndConfirm capa=1 es la mano derecha: por otra cosa, pasa su capa real.
UO.EquipItems · UO.UnequipItems · UO.DressSpeed · UO.DropDelay · UO.ObjAtLayerEx

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.

int item = UO.LastTarget();
if (item != 0)
    UO.Print("Accepted flag: " + UO.Equip(1, item));

1. Equip - Un elemento o capa seleccionado - script directo

Parámetros y flujo de ejecución:

Primero, selecciona el elemento apropiado en el juego: lasttarget - es ID. En el ejemplo Equip/WearItem, la capa 1 requiere un arma de mano izquierda. Unequip(1) quita la mano derecha; Disarm/Undress funcionan con sus propias capas fijas. No hay repeticiones automáticas después de un rechazo.

var item = Asc(UO.GetSerial("lasttarget"), 0);
if (Truth(item == 0))
{
    return 0;
}
return UO.Equip(1, item);

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

2. Equip - Dos elementos y guardados ID - función de script

Parámetros y flujo de ejecución:

Para equipar, 0x0F5E es un ejemplo de espada, 0x1B76 es un ejemplo de escudo. FindType los busca entre los elementos cargados de la mochila, ASC convierte el hexadecimal devuelto-ID. Para eliminarlas se leen las propias capas actuales. Si el elemento requerido no está disponible, el script finaliza. La matriz almacena dos ID; Cada artículo se transfiere en su totalidad.

return  RunScenario();
 object? RunScenario()
{
    var first = Asc(UO.FindType(0x0F5E, -1, "backpack"), 0);
    var second = Asc(UO.FindType(0x1B76, -1, "backpack"), 0);
    if (Truth(first == 0) || Truth(second == 0))
    {
        return 0;
    }

    UO.AddObject("saved_first", first);
    UO.AddObject("saved_second", second);
    var firstOk = UO.Equip(1, first);
    var secondOk = UO.Equip(2, second);
    return firstOk != 0 && secondOk != 0;
    return null;
}

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

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

3. Equip - Función completa con espera limitada - clase de script

Parámetros y flujo de ejecución:

ChangeAndConfirm ejecuta el comando una vez. Luego verifica el estado real hasta 20 veces con una pausa de 100 ms. 1 - la verificación vio el estado esperado, 0 - falla o espera vencida. Este es el resultado de nuestro asistente, no un nuevo comando integrado. Llamar a la operación en sí también puede llevar tiempo.

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 item = Asc(UO.GetSerial("lasttarget"), 0);
        if (Truth(item == 0))
        {
            return 0;
        }

        return ChangeAndConfirm(1, item);
        return null;
    }

    dynamic ChangeAndConfirm(dynamic layer, dynamic item)
    {
        if (Truth(item == 0))
        {
            return 0;
        }

        if (!(Truth(UO.Equip(layer, item))))
        {
            return 0;
        }

        for (int attempt = (int)(1); attempt <= 20; attempt += (int)(1))
        {
            if (Truth(UO.ObjAtLayerEx(layer, UO.Self()) == item))
            {
                return 1;
            }

            UO.Wait(100);
        }

        return 0;
    }

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

    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.Equip(layer, id)` — `UO.Equip(Any,Any)`

Parámetros: layer (Any/String), id (Any/Integer/String)

Resultado: int / Any.

Durante la llamada:

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

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

case "equip":

                    return new InjectionValue(arguments[0].Kind == InjectionValueKind.String ? Equip(Text(0), Arg(1)) : bridge.Equip(Arg(0), Arg(1)));

`UO.Equip(layer, id)` — `UO.Equip(String,Integer)`

Parámetros: layer (Any/String), id (Any/Integer/String)

Resultado: int / Integer.

Durante la llamada:

InjectionScript.Runtime.InjectionApiUO.Equip.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Equip: bridge.Equip(ConvertLayer(layer), id).
InjectionScript.Runtime.InjectionApiUO.ConvertLayer: ConvertLayer(layer).

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

public int Equip(string layer, int id) => bridge.Equip(ConvertLayer(layer), id);

`UO.Equip(layer, id)` — `UO.Equip(String,String)`

Parámetros: layer (Any/String), id (Any/Integer/String)

Resultado: int / Integer.

Durante la llamada:

InjectionScript.Runtime.InjectionApiUO.Equip.
InjectionScript.Runtime.InjectionApiUO.Equip: Equip(layer, GetObject(id)).
InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(id).

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

public int Equip(string layer, string id) => Equip(layer, GetObject(id));

UO.EquipDressSet

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

Firmas de C#

dynamic UO.EquipDressSet();

Nombre alternativo DressSavedSet: Restaura el mismo conjunto de ropa sin nombre.

Parámetros

No hay parámetros.

Valor devuelto

De hecho, indicador numérico int: 1 (condición cumplida): todas las solicitudes necesarias se aceptan localmente o las capas necesarias ya coinciden; 0 (condición no cumplida): no se realizó marcación, no hubo conexión o al menos una solicitud fue rechazada. ¿Registro object? permite esto int. Esto no es ID, la cantidad de artículos usados o la confirmación del servidor.

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

Ropa: capas 3,4,5,6,7,8,10,12,13,14,17,18,19,20,22,23,24. Armas: 1 y 2 únicamente. Pelo, barba, mochila, animal y banco no están incluidos en estos sets.
Los elementos específicos serial ya cargados se registran en sus propias capas. Guardar el mismo nombre nuevamente reemplaza la entrada. Las capas vacías también tienen sentido: cuando se restauren, la capa ocupada correspondiente se liberará en su propia mochila. Por lo tanto, un conjunto guardado completamente vacío elimina elementos de sus capas.
El conjunto se almacena en el estado de tiempo de ejecución. La llamada en sí no crea un archivo y no garantiza que el conjunto se transfiera a otro perfil o a un nuevo tiempo de ejecución. Primero, guarde el conjunto deseado en su estado usado. Cargar/guardar el estado general del cliente es un mecanismo separado.
Se omite una coincidencia exacta entre el ID actual y el guardado, sin volver a utilizarlo o generarlo. Un elemento faltante no se reemplaza por un type similar. El fracaso de una operación no anula las exitosas ni interfiere con los intentos de otras; No hay reversión automática. Necesita conexión y cosas cargadas. Cuando se retira, se utiliza una mochila real.
UO.Set("equipfordress", 0) selecciona la solicitud para utilizar el elemento (modo inicial); valor distinto de cero - recogida/equipamiento. La capa portátil deseada se comprueba en ambos modos. Un artículo ya usado no se puede cambiar mediante un uso repetido. DressSpeed es válido después de la solicitud aceptada, el retiro respeta adicionalmente DropDelay.
Dress y Arm devuelven null incluso en caso de falla. El mensaje de que las solicitudes han sido aceptadas no significa confirmación por parte del servidor. Para una continuación que depende de la colocación, verifique las capas reales con expectativas limitadas.
UO.SetDress · UO.Dress · UO.DressSavedSet · UO.SetArm · UO.Arm · UO.DressSpeed

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

1. Uso directo - guión directo

Parámetros y flujo de ejecución:

El conjunto requerido debe guardarse anteriormente en el mismo estado de ejecución. No llame a SetDress/SetArm justo antes de cada restauración: esto sobrescribirá el objetivo con los elementos actuales.

return UO.EquipDressSet();

2. Nombres y modo de consulta: función de secuencia de comandos

Parámetros y flujo de ejecución:

Un equipo distinto de cero selecciona recoger/equipar; 350 — milisegundos DressSpeed. Estas configuraciones permanecen en tiempo de ejecución después del ejemplo. La retirada y colocación la decide el servidor.

return  RunScenario();
 object? RunScenario()
{
    UO.Set("equipfordress", 1);
    UO.DressSpeed(350);
    return UO.EquipDressSet();
    return null;
}

3. Script auxiliar completo - Clase de script

Parámetros y flujo de ejecución:

lasttarget: ID cosas que deberían incluirse en un conjunto previamente guardado. La capa de control 3 significa zapatos, 1 significa mano derecha. AwaitSlot compensa hasta 20 comprobaciones con una pausa de 100 ms y no repite el comando. Esto confirma sólo el elemento seleccionado, no todo el conjunto.

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 expected = Asc(UO.GetSerial("lasttarget"), 0);
        if (Truth(expected == 0))
        {
            return 0;
        }

        if (!(Truth(UO.EquipDressSet())))
        {
            return 0;
        }

        return AwaitSlot(3, expected);
        return null;
    }

    dynamic AwaitSlot(dynamic layer, dynamic expected)
    {
        for (int attempt = (int)(1); attempt <= 20; attempt += (int)(1))
        {
            if (Truth(UO.ObjAtLayerEx(layer, UO.Self()) == expected))
            {
                return 1;
            }

            UO.Wait(100);
        }

        return 0;
    }

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

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

Parámetros: Sin parámetros.

Resultado: dynamic / Any.

Durante la llamada:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
InjectionScript.Runtime.InjectionApiUO.Equip: Equip("__stealth_saved_set__", dressSets, dressLayers, "Clothing set requests processed.", "No clothing set with setdress.").

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

case "dresssavedset":

                case "equipdressset": return new InjectionValue(Equip("__stealth_saved_set__", dressSets, dressLayers, "Clothing set requests processed.", "No clothing set with setdress."));

UO.EquipItems

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

Firmas de C#

dynamic UO.EquipItems(object? items);

Equipa un artículo o una variedad de artículos. La capa de cada artículo está determinada por sus datos de uso, por lo que el artículo se puede poner desde una mochila.

Parámetros

items: ID obligatorio o conjunto ID de elementos. Los elementos de la matriz son números o cadenas hexadecimales numéricas. El argumento único también acepta "lasttarget"/nombre AddObject. Para una matriz, use los elementos de declaración de variables [1] para dos elementos en los índices 0 y 1. Se transmiten cosas, no números de capa ni type.

Valor devuelto

Bandera numérica int: 1 (condición cumplida) - operación local aceptada, 0 (condición no cumplida) - negativa. Esto no es una confirmación del servidor, ni ID, ni una cantidad. El servidor puede fallar más tarde; Verifique el equipo real después de responder.

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

Necesita elementos cargados y arrastre con las manos libres. Cuando se retira, se requiere la mochila self real: la GrabBag de repuesto no se utiliza. Se rechazan los artículos desconocidos, destruidos o inadecuados. Los artículos de otras personas no se pueden eliminar mediante UnequipItems. Un conjunto no es una transacción atómica.
EquipItems/UnequipItems aplica DressSpeed después de la operación aceptada antes del siguiente elemento; Disarm/Undress - después de cada capa ocupada. El retiro también respeta DropDelay cuando se acepta el acarreo. Las mismas configuraciones de otros tiempos de ejecución no cambian; La aceleración no anula las limitaciones del servidor.
Un formulario de llamada incorrecto, un nombre de capa desconocido o un valor que no se puede convertir en un número pueden provocar un error de secuencia de comandos en lugar de 0. La instantánea del equipo solo contiene datos que ya se han cargado. En el asistente, ChangeAndConfirm capa=1 es la mano derecha: por otra cosa, pasa su capa real.
Para una matriz, 1 significa que se aceptan todas las operaciones enumeradas; en caso de rechazo, se devuelve 0. Los elementos restantes aún se procesan, no hay reversión. Una matriz vacía produce 1 sin acción. Disarm/Undress dé 1 también cuando las capas requeridas ya estén vacías; el fallo parcial da 0.
UO.EquipItems · UO.UnequipItems · UO.DressSpeed · UO.DropDelay · UO.ObjAtLayerEx

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

1. EquipItems - Un elemento o capa seleccionado - script directo

Parámetros y flujo de ejecución:

Primero, selecciona el elemento apropiado en el juego: lasttarget - es ID. En el ejemplo Equip/WearItem, la capa 1 requiere un arma de mano izquierda. Unequip(1) quita la mano derecha; Disarm/Undress funcionan con sus propias capas fijas. No hay repeticiones automáticas después de un rechazo.

var item = Asc(UO.GetSerial("lasttarget"), 0);
if (Truth(item == 0))
{
    return 0;
}
return UO.EquipItems(item);

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

2. EquipItems - Dos elementos y guardados ID - función de script

Parámetros y flujo de ejecución:

Para equipar, 0x0F5E es un ejemplo de espada, 0x1B76 es un ejemplo de escudo. FindType los busca entre los elementos cargados de la mochila, ASC convierte el hexadecimal devuelto-ID. Para eliminarlas se leen las propias capas actuales. Si el elemento requerido no está disponible, el script finaliza. La matriz almacena dos ID; Cada artículo se transfiere en su totalidad.

return  RunScenario();
 object? RunScenario()
{
    var first = Asc(UO.FindType(0x0F5E, -1, "backpack"), 0);
    var second = Asc(UO.FindType(0x1B76, -1, "backpack"), 0);
    if (Truth(first == 0) || Truth(second == 0))
    {
        return 0;
    }

    UO.AddObject("saved_first", first);
    UO.AddObject("saved_second", second);
    dynamic[] items = new dynamic[checked((int)(1) + 1)];
    items[0] = first;
    items[1] = second;
    return UO.EquipItems(items);
    return null;
}

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

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

3. EquipItems - Función completa con espera limitada - clase de script

Parámetros y flujo de ejecución:

ChangeAndConfirm ejecuta el comando una vez. Luego verifica el estado real hasta 20 veces con una pausa de 100 ms. 1 - la verificación vio el estado esperado, 0 - falla o espera vencida. Este es el resultado de nuestro asistente, no un nuevo comando integrado. Llamar a la operación en sí también puede llevar tiempo.

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 item = Asc(UO.GetSerial("lasttarget"), 0);
        if (Truth(item == 0))
        {
            return 0;
        }

        return ChangeAndConfirm(1, item);
        return null;
    }

    dynamic ChangeAndConfirm(dynamic layer, dynamic item)
    {
        if (Truth(item == 0))
        {
            return 0;
        }

        if (!(Truth(UO.EquipItems(item))))
        {
            return 0;
        }

        for (int attempt = (int)(1); attempt <= 20; attempt += (int)(1))
        {
            if (Truth(UO.ObjAtLayerEx(layer, UO.Self()) == item))
            {
                return 1;
            }

            UO.Wait(100);
        }

        return 0;
    }

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

    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.EquipItems(items)` — `UO.EquipItems(Any)`

Parámetros: items (Any)

Resultado: dynamic / Any.

Durante la llamada:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
InjectionScript.Runtime.InjectionApiUO.ChangeEquipmentItems: ChangeEquipmentItems(ArrayArg(0), true).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::ArrayArg: ArrayArg(0).

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

case "equipitems":

                    return new InjectionValue(ChangeEquipmentItems(ArrayArg(0), true));

UO.EquipLastWeapon

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

Firmas de C#

void UO.EquipLastWeapon();

Solicita reequipamiento de los últimos elementos guardados a mano derecha e izquierda.

Parámetros

No hay parámetros.

Valor devuelto

void: sin valor de retorno.

Comportamiento

El puente almacena _lastRightHand y _lastLeftHand. Una derecha distinta de cero serial se transmite Equip(OneHanded), una izquierda distinta de cero - Equip(TwoHanded). Se omiten las entradas vacías. Estas son dos solicitudes posibles, no una recuperación atómica confirmada por 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 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.EquipLastWeapon");
UO.EquipLastWeapon();

1. Restaurar arma - guión directo

Parámetros y flujo de ejecución:

Sólo se utilizan las manos guardadas del puente serial.

UO.EquipLastWeapon();

2. Si hay una conexión - función de script

Parámetros y flujo de ejecución:

Las pruebas de conexión se realizan antes de enviar las solicitudes.

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

    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. Procedimiento de recuperación: clase de script

Parámetros y flujo de ejecución:

Un ayudante completamente declarado hace que se restablezca un par de manos.

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()
    {
        RestoreWeapons();
        return null;
    }

    void RestoreWeapons()
    {
        UO.EquipLastWeapon();
    }
}

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

Parámetros: Sin parámetros.

Resultado: void / Unit.

Durante la llamada:

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

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

case "equiplastweapon": bridge.EquipLastWeapon(); return InjectionValue.Unit;

UO.EquipT

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

Firmas de C#

void UO.EquipT(object? layer, object? @type);

Parámetros

layer — Capa de equipo. La línea "Rhand" es la mano derecha (1), "Lhand" es la mano izquierda (2); un número numérico también es aceptable. Todos los nombres reconocidos se enumeran en la tabla de capas. La cadena "1" no reemplaza el número 1: un nombre de cadena desconocido provoca un error. Seleccione la capa real de la cosa en sí: el comando no cambia su ranura válida.
type - Un elemento graphic, por ejemplo 0x0F51 - una daga. No es serial de una cosa particular ni graphic de un cuerpo mobile. Un número o una cadena hexadecimal numérica. No se especifica el color: se busca cualquier hue; la búsqueda incluye recursivamente los subcontenedores cargados de la mochila. -1/0xFFFF ya que las búsquedas con comodines aquí son prácticamente inútiles para elegir armas: se tomará lo primero que pueda no coincidir con la capa.

Valor devuelto

void: este formulario C# no devuelve un valor. No asigne su llamada a una variable y no la use en if. Para probar la aceptación de una solicitud con dos argumentos enteros, utilice UO.Equipt. En ambos casos, verifique el equipo real después de que el servidor responda mediante ObjAtLayer y GetType.

Comportamiento

Ambos argumentos son necesarios. Primero FindType busca un artículo en la mochila, luego Equip comprueba su idoneidad. La búsqueda actualiza los resultados generales FindItem/FindCount/GetFoundItems. Si hay varias coincidencias, se selecciona el primer elemento adecuado para la búsqueda; No existe una opción separada para la calidad, hue o el nombre.
El cliente comprueba la bandera portátil, la capa real del artículo (1..29) y la capacidad de levantarlo. El artículo debe estar cargado. El servidor decide además si se permite su uso; una solicitud local aceptada no demuestra el éxito.
Si falta un elemento, el formulario void muestra el mensaje No se encontró ningún elemento; la forma numérica devuelve 0. Si necesita seleccionar un elemento específico por color/serial, use FindType y Equip por separado. UO.Equip toma ID del elemento encontrado.
Mientras espera una respuesta, no inicie otra transferencia de artículo al mismo tiempo. Verifique los cambios de capa en lugar de repetir la acción sin cesar.

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.EquipT");
UO.EquipT("Rhand", 0x0F51);

1. Equipar daga por nombre de capa de cuerda - script directo

Parámetros y flujo de ejecución:

La línea Rhand selecciona la capa de la derecha. La daga debe ser accesible en una mochila cargada. Cualquier color; el número de argumentos es siempre dos.

if (Truth(UO.Connected()))
{
    UO.EquipT("Rhand", 0x0F51);
}

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

2. Manejar error en el formulario de número: función de secuencia de comandos

Parámetros y flujo de ejecución:

1 - capa, 0x0F51 - type. La cadena C# forma EquipT devuelve void; La aceptación de una solicitud no puede verificarse por su resultado. 300 ms - espera breve, por ejemplo; la ausencia de una cosa después de que no prueba una falla definitiva del servidor.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    UO.EquipT("Rhand", 0x0F51);
    await Delay(300);
    var worn = UO.ObjAtLayer(1);
    if (Truth(worn != 0) && Truth(UO.GetType(worn) == 0x0F51))
    {
        UO.AddObject("equipped_dagger", worn);
    }

    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 completa: póngase y espere el type deseado - clase de escenario

Parámetros y flujo de ejecución:

timeoutMs=2000 especifica la espera máxima en milisegundos. Comprobar cada 50 ms no envía reequipamiento. El true de esta función personalizada significa que el cliente ya ve el type deseado en la capa; Este es un control más fuerte que la aceptación de la solicitud Equipt devuelta.

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

    async public Task<object?> RunScenarioAsync()
    {
        if (Truth(UO.Connected()) && !(Truth(await EnsureDagger(2000))))
        {
            UO.Print("Dagger was not confirmed within the timeout");
        }

        return null;
    }

    async Task<dynamic> EnsureDagger(dynamic timeoutMs)
    {
        var worn = UO.ObjAtLayer(1);
        if (Truth(worn != 0) && Truth(UO.GetType(worn) == 0x0F51))
        {
            return true;
        }

        UO.EquipT("Rhand", 0x0F51);
        var started = Now();
        while (Truth(Now() - started < timeoutMs))
        {
            await Delay(50);
            worn = UO.ObjAtLayer(1);
            if (Truth(worn != 0) && Truth(UO.GetType(worn) == 0x0F51))
            {
                return true;
            }
        }

        return false;
    }

    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;
    private int Now() => global::ClassicUO.CSharp.CSharpScriptContext.Current.Now();
}

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.EquipT(layer, type)` — `UO.EquipT(Any,Any)`

Parámetros: layer (Any), type (Any)

Resultado: void / Unit.

Durante la llamada:

InjectionScript.Runtime.InjectionApiUO.EquipT.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.FindType: bridge.FindType(ResolveType(type), -1, bridge.Backpack, -1, true).
InjectionScript.Runtime.InjectionApiUO.ResolveType: ResolveType(type).
InjectionScript.Runtime.InjectionApiUO.SystemMessage: SystemMessage("No item found.").
InjectionScript.Runtime.InjectionApiUO.Equip: Equip(layer.String, obj).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Equip: bridge.Equip(NumberConversions.ToInt(layer), obj).
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(layer).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Backpack: bridge.Backpack.

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

public void EquipT(InjectionValue layer, InjectionValue type)

        {

            var obj = bridge.FindType(ResolveType(type), -1, bridge.Backpack, -1, true);

            if (obj == 0)

            {

                SystemMessage("No item found.");

                return;

            }



            if (layer.Kind == InjectionValueKind.String)

                Equip(layer.String, obj);

            else

                bridge.Equip(NumberConversions.ToInt(layer), obj);

        }

UO.Equipt

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

Firmas de C#

int UO.Equipt(object? layer, object? @type);

Parámetros

layer / capa: número entero de la capa del equipo. Mano derecha - 1, izquierda - 2. Elija un espacio para artículos real.
type / type: un graphic completo de un artículo, por ejemplo 0x0F51 para una daga. Esto no es serial. Busca cualquier hue en el contenido cargado de la mochila y los contenedores anidados.

Valor devuelto

Este formulario C# devuelve int: 1 si el cliente aceptó la solicitud de vestimenta, 0 en caso contrario. Pase dos números enteros (número de capa y graphic); Los valores de cadena seleccionan un contrato de tiempo de ejecución diferente y no son adecuados para este formulario. La llamada no espera la confirmación del servidor. Para un nombre de capa de cadena, use UO.EquipT, que devuelve void.

Comportamiento

Ambos argumentos son necesarios. Primero FindType busca un artículo en la mochila, luego Equip comprueba su idoneidad. La búsqueda actualiza los resultados generales FindItem/FindCount/GetFoundItems. Si hay varias coincidencias, se selecciona el primer elemento adecuado para la búsqueda; No existe una opción separada para la calidad, hue o el nombre.
El cliente comprueba la bandera portátil, la capa real del artículo (1..29) y la capacidad de levantarlo. El artículo debe estar cargado. El servidor decide además si se permite su uso; una solicitud local aceptada no demuestra el éxito.
Si falta un elemento, el formulario null muestra el mensaje No se encontró ningún elemento; la forma numérica devuelve 0. Si necesita seleccionar un elemento específico por color/serial, use FindType y Equip por separado. UO.Equip toma ID del elemento encontrado.
Mientras espera una respuesta, no inicie otra transferencia de artículo al mismo tiempo. Verifique los cambios de capa en lugar de repetir la acción sin cesar.

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

1. Solicitar equipo de daga mediante graphic - guión directo

Parámetros y flujo de ejecución:

Ambos argumentos son números enteros: capa 1 y graphic de la daga. El valor 1 confirma que la solicitud fue aceptada por el cliente y no por el servidor.

int accepted = UO.Equipt(1, 0x0F51);
UO.Print(accepted != 0 ? "Equip request accepted locally" : "Equip request not accepted");

2. Comprobar ranura después de la solicitud: función de script

Parámetros y flujo de ejecución:

Esperar no sustituye a la comprobación: se lee lo real en la capa. El guión no repite la transferencia infinitamente.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    int accepted = UO.Equipt(1, 0x0F51);
    if (accepted == 0)
        return false;
    await WaitAsync(300);
    int worn = UO.ObjAtLayer(1);
    return worn != 0 && UO.GetType(worn) == 0x0F51;
    return null;
}

3. Úselo solo cuando el artículo requerido no esté disponible - clase de escenario

Parámetros y flujo de ejecución:

En primer lugar, se comprueba el equipamiento actual; Después de una solicitud, la verificación se limita a veinte intentos.

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()
    {
        return await EnsureDagger();
        return null;
    }

    async Task<bool> EnsureDagger()
    {
        int current = UO.ObjAtLayer(1);
        if (current != 0 && UO.GetType(current) == 0x0F51)
            return true;
        if (UO.Equipt(1, 0x0F51) == 0)
            return false;
        for (int attempt = 0; attempt < 20; attempt++)
        {
            await WaitAsync(100);
            current = UO.ObjAtLayer(1);
            if (current != 0 && UO.GetType(current) == 0x0F51)
                return true;
        }

        return false;
    }
}

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.Equipt(layer, type)` — `UO.Equipt(Integer,Integer)`

Parámetros: layer (Integer), type (Integer)

Resultado: int / Integer.

Durante la llamada:

InjectionScript.Runtime.InjectionApiUO.Equipt.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.FindType: bridge.FindType(type, -1, bridge.Backpack, -1, true).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Equip: bridge.Equip(layer, item).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Backpack: bridge.Backpack.

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

public int Equipt(int layer, int type)

        {

            int item = bridge.FindType(type, -1, bridge.Backpack, -1, true);

            return item == 0 ? 0 : bridge.Equip(layer, item);

        }

UO.FireResist

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

Firmas de C#

int UO.FireResist();

Lee el campo de resistencia del personaje actual: fuego.

Parámetros

No hay parámetros.

Valor devuelto

int: valor de estado firmado, -32768..32767 en el modelo de cliente. El valor negativo se mantiene. 0 puede ser una resistencia real, falta de datos o un jugador perdido/destruido; GetResist también da 0 para un selector desconocido. Esto no es un límite bool, ID, de habilidad o resistencia. 1 significa un punto, no éxito.

Comportamiento

El comando no acepta argumentos. Utilice las firmas exactas anteriores.
La lectura del hilo del juego requiere Jugador.FireResistance si el Jugador actual existe y no ha sido destruido; en caso contrario 0. El equipo no se clasifica, las bonificaciones no se recalculan, no se solicita el estado y no hay que esperar actualizaciones. Un fantasma presente no es igual a un Jugador destruido.
Los campos elementales vienen en formato extendido CharacterStatus (0x11), type >= 4. El comando en sí no verifica la época del servidor. El estado compacto/antiguo sin estos campos deja el caché anterior; El nuevo jugador es inicialmente 0. La resistencia al veneno no es una bandera Poisoned; Tampoco es una habilidad de resistencia a hechizos.
CharacterStatus verifica el cuerpo requerido antes de cambiar el nombre, la salud y las características propias, luego traduce cada palabra de resistencia a un Int16 firmado. Un cuerpo obligatorio recortado no modifica los datos anteriores. La cola opcional type 6 conserva las mismas reglas; Los comandos de resistencia no leen los límites máximos.
Cada llamada lee los datos locales de nuevo. La variable almacena la instantánea; las lecturas individuales pueden recibir diferentes actualizaciones del servidor. Un resultado distinto de cero no prueba la conexión. Cero puede ser un valor o ningún dato.
Estas funciones registran la API. No se ejecutan de nuevo en cada llamada al 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.

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

1. Imprimir valor guardado - script directo

Parámetros y flujo de ejecución:

El valor almacena el resultado de una llamada. Convertir.ToString formatea el número del registro. No hay argumentos: puedes leer tu propio personaje.

var value = UO.FireResist();
UO.Print("FireResistance: " + Convert.ToString(value));

2. Comparar dos imágenes - función de script

Parámetros y flujo de ejecución:

Entre antes y después hay UO.Wait(500) milisegundos; la diferencia puede ser negativa. Es posible que se pierdan actualizaciones provisionales. La pausa se refiere al ejemplo, no al retraso API.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.FireResist();
    await Delay(500);
    var after = UO.FireResist();
    var difference = after - before;
    UO.Print("Resistance change: " + Convert.ToString(difference));
    return null;
}

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

3. Función de prueba de resistencia mínima completa: clase de script

Parámetros y flujo de ejecución:

mínimo=50 es un ejemplo de requisito, no de límite de clientes. ResistanceAtLeast rechaza al jugador que falta, lee un valor y devuelve bool: true o false si el valor >= mínimo. La resistencia en sí no es bool. La función se declara completamente a continuació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()
    {
        if (Truth(Truth(ResistanceAtLeast(50)) == true))
        {
            UO.Print("Local resistance requirement met");
        }
        else
        {
            UO.Print("Requirement not met or no player");
        }

        return null;
    }

    dynamic ResistanceAtLeast(dynamic minimum)
    {
        if (Truth(UO.Self() == 0))
        {
            return false;
        }

        var value = UO.FireResist();
        return value >= minimum;
    }

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

Parámetros: Sin parámetros.

Resultado: int / Integer.

Durante la llamada:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.FireResistance: bridge.FireResistance.

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

case "fireresist": return new InjectionValue(bridge.FireResistance);

UO.Flying

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

Firmas de C#

int UO.Flying();
int UO.Flying(object? id);

Comprueba si el personaje está volando actualmente. Esto suele ser necesario para Gargoyle: por ejemplo, antes de iniciar una ruta o antes de solicitar habilitar un vuelo. Responde a la pregunta “¿mi personaje está volando ahora?” sin argumento. El comando sólo lee el estado: no permite volar, aterrizar ni mover al personaje.

Parámetros

id: carácter serial opcional: número, cadena hexadecimal, self, lasttarget o nombre almacenado mediante UO.AddObject. Sin argumentos, se utiliza tu personaje. Esto es ID de mobile específico, no graphic/type y no la coordenada de Z. Un nombre desconocido, falta/eliminado mobile o un elemento indica 0.

Valor devuelto

Bandera numérica int: 1 (condición cumplida), 0 (condición no cumplida). Esta es una bandera numérica: en C# verifique el resultado! = 0 o resultado == 0. Comparación directa de int con true/false y si (resultado) no está permitido. 1 - mobile tiene IsFlying, 0 no tiene bandera o mobile falta. La altitud Z por sí sola no significa vuelo.

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

La principal aplicación del juego es el vuelo de Gargoyle. Sin embargo, el captador no verifica la carrera: en este cliente lee el bit 0x04 de mobile con la versión de protocolo 7.0.0.0 y posterior. En el protocolo anterior, devuelve 0. Pararse sobre un techo, Z alto, animaciones de alas o la carrera de Gárgolas en sí no son pruebas de vuelo habilitadas.
Hay un UO.ToggleFly() separado para cambiar de estado: envía una solicitud de cambio en lugar de un comando de "encendido". Si ya está volando, una nueva llamada solicita el aterrizaje. El servidor puede fallar; después de que se le indique, lea Flying nuevamente con una espera limitada. false también es posible sin caracteres/datos disponibles, así que marca Connected antes de realizar la acción.
Lee el modelo local: no abre el destino, no solicita el estado, no cambia la bandera y no envía el paquete. Un objeto destruido se considera perdido incluso antes de que la entrada se elimine del diccionario.
El resultado es una lectura separada. El mundo puede cambiar entre Exists y el próximo desafío; varias consultas no forman una instantánea atómica.

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

1. Modo de verificación antes del siguiente paso del guión: guión directo

Parámetros y flujo de ejecución:

Los paréntesis vacíos indican self. true es igual a 1, false es igual a 0; si UO.Flying() {...} es aceptable. Este ejemplo no cambia nada.

var active = UO.Flying();
if (Truth(Truth(active) == true))
{
    UO.Print("Flying mode active");
}
else
{
    UO.Print("Ground mode or character data unavailable");
}

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

2. Verificar carácter previamente seleccionado - función script

Parámetros y flujo de ejecución:

ReadState(obj) toma serial/alias y devuelve el estado. La definición completa se encuentra a continuación; la ausencia de un objeto se maneja antes de la lectura. El carácter de otra persona también se compara con los datos ya recibidos por el cliente.

return  RunScenario();
 object? RunScenario()
{
    var target = Asc(UO.GetSerial("lasttarget"), 0);
    if (Truth(target != 0) && Truth(UO.Exists(target)))
    {
        if (Truth(ReadState(target)))
        {
            UO.AddObject("flying_mobile", target);
        }
    }

    return null;
}

dynamic ReadState(dynamic obj)
{
    if (!(Truth(UO.Exists(obj))))
    {
        return false;
    }

    return UO.Flying(obj);
}

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

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

3. Solicite un vuelo una vez y espere el resultado - clase de escenario

Parámetros y flujo de ejecución:

El ejemplo es para tu Gargoyle en un servidor que admite vuelos. EnsureFlight(timeoutMs) devuelve 1/true si se observa vuelo; en caso contrario, 0/false. 2000 — límite de espera en milisegundos; comprueba cada 50 ms. Si ya estás volando, no se llama a ToggleFly. Se envía como máximo una solicitud y luego se verifica el estado de la respuesta. La pausa del script/el retraso del programador pueden aumentar el tiempo real.

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

    async public Task<object?> RunScenarioAsync()
    {
        if (Truth(await EnsureFlight(2000)))
        {
            UO.Print("Flight confirmed; ready for the next stage");
        }
        else
        {
            UO.Print("Flight not confirmed; route was not started");
        }

        return null;
    }

    async Task<dynamic> EnsureFlight(dynamic timeoutMs)
    {
        if (!(Truth(UO.Connected())) || Truth(UO.Dead()))
        {
            return false;
        }

        if (Truth(UO.Flying()))
        {
            return true;
        }

        UO.ToggleFly();
        var waited = 0;
        while (Truth(waited < timeoutMs))
        {
            if (!(Truth(UO.Connected())))
            {
                return false;
            }

            if (Truth(UO.Flying()))
            {
                return true;
            }

            await Delay(50);
            waited += 50;
        }

        return UO.Flying();
    }

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

Parámetros: Sin parámetros.

Resultado: int / Integer.

Durante la llamada:

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

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

public int Flying() => bridge.Flying(bridge.Self);

`UO.Flying(id)` — `UO.Flying(Any)`

Parámetros: id (Any)

Resultado: int / Integer.

Durante la llamada:

InjectionScript.Runtime.InjectionApiUO.Flying.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Flying: bridge.Flying(GetObject(id)).
InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(id).

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

public int Flying(InjectionValue id) => bridge.Flying(GetObject(id));

UO.Frozen

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

Firmas de C#

int UO.Frozen();
int UO.Frozen(object? value);

Comprueba la bandera de parálisis del personaje conocida por el cliente.

Parámetros

value - Opcional serial/ID mobile: número, cadena hexadecimal, self, lasttarget u otro nombre de objeto estándar o nombre AddObject. Esto no es graphic/type. Sin argumento, se utiliza self. El nombre desconocido se resuelve en 0; El objetivo no se abre.

Valor devuelto

Indicador numérico int: 1 (condición cumplida): cargado mobile tiene el indicador IsParalyzed; 0 (condición no cumplida): sin indicador, mobile desconocido, eliminado o el objeto es un elemento. Este no es un momento de parálisis y no garantiza la capacidad de moverse con un resultado de 0.

Comportamiento

Utilice Paralyzed para comprobar la bandera de parálisis. Las variantes Is/Get, GetParalisa, Frozen y GetLocked leen la misma bandera.
El comando solo lee datos locales. No aplica ni elimina la parálisis, no espera a que finalice y no envía una solicitud de actualización al servidor.
El resultado de este comando es de tipo int: use if (valor!= 0) o if (valor == 0). No se permiten comparaciones directas con true/false y si (valor) en C#. El valor conserva el significado de la bandera, no la cantidad o ID.

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

1. Ponte a prueba a través de true - script directo

Parámetros y flujo de ejecución:

Los paréntesis vacíos seleccionan self. el estado almacena una instantánea de la bandera; true es la constante numérica 1.
Un resultado de false no descarta una pared, falta de resistencia u otra razón para detenerse.

var state = UO.Frozen();
if (Truth(Truth(state) == true))
{
    UO.Print("Paralysis flag is set");
}
else
{
    UO.Print("Paralysis flag is absent or unavailable");
}

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

2. Marque seleccionado mobile - función de script

Parámetros y flujo de ejecución:

El objetivo almacena la cadena hexadecimal serial del último objetivo. IsNpc comprueba que sea el mobile cargado, incluidos los jugadores.
El comando con el argumento dice objetivo. Ella no elige un nuevo personaje ni cambia lasttarget.

return  RunScenario();
 object? RunScenario()
{
    var target = UO.GetSerial("lasttarget");
    if (Truth(UO.IsNPC(target)))
    {
        var state = UO.Frozen(target);
        UO.Print("Selected mobile paralysis 1/0: " + Convert.ToString(state));
    }
    else
    {
        UO.Print("No loaded mobile selected");
    }

    return null;
}

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

3. Espera limitada para que se elimine la parálisis: clase de escenario

Parámetros y flujo de ejecución:

No más de 10 pausas durante 100 ms. Cada llamada sin argumento se lee self nuevamente.
Después del ciclo, se comprueba por separado la presencia de self. Esta es una observación durante aproximadamente un segundo más la ejecución de comandos, y no una eliminación garantizada de la parálisis.

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 attempts = 0;
        while (Truth(Truth(UO.Frozen()) == true) && Truth(attempts < 10))
        {
            await Delay(100);
            attempts = attempts + 1;
        }

        if (Truth(UO.IsNPC("self")))
        {
            if (Truth(Truth(UO.Frozen()) == false))
            {
                UO.Print("Paralysis flag is clear");
            }
            else
            {
                UO.Print("Still paralyzed");
            }
        }
        else
        {
            UO.Print("Self is unavailable");
        }

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

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

Parámetros: Sin parámetros.

Resultado: int / Integer.

Durante la llamada:

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [Frozen].
InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetLocked: bridge.GetLocked(serial).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self: bridge.Self.

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.

serial => bridge.GetLocked(serial)

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

() => getter(bridge.Self)

Creación de API: Estas funciones registran la API. No se ejecutan de nuevo en cada llamada al comando.

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddState.

`UO.Frozen(value)` — `UO.Frozen(Any)`

Parámetros: value (Any)

Resultado: int / Integer.

Durante la llamada:

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [Frozen].
InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetLocked: bridge.GetLocked(serial).
InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(value).

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.

serial => bridge.GetLocked(serial)

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

value => getter(GetObject(value))

Creación de API: Estas funciones registran la API. No se ejecutan de nuevo en cada llamada al comando.

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddState.

UO.GetARStatus

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

Firmas de C#

dynamic UO.GetARStatus();

Lee el indicador para la reconexión automática de la sesión actual del administrador o del cliente global.

Parámetros

No hay parámetros.

Valor devuelto

int 1: la reconexión automática está habilitada; 0 — deshabilitado.

Comportamiento

SessionControl.AutoReconnect tiene prioridad. Si falta SessionControl, se utiliza Configuración.GlobalSettings.Reconectar. Esta es una configuración, no el estado de la conexión actual o el número de intentos.

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.GetARStatus();
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:

La lectura no se conecta.

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

2. Asignar a conexión: función de secuencia de comandos

Parámetros y flujo de ejecución:

La configuración AR y la conexión real son dos valores separados.

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

3. Conexión manual cuando AR está desactivado - clase de escenario

Parámetros y flujo de ejecución:

Connect se permite manualmente cuando la reconexión automática está deshabilitada.

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

     public object? RunScenario()
    {
        if (Truth(UO.GetARStatus() == 0) && !(Truth(UO.Connected())))
        {
            UO.Connect();
        }

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

Parámetros: Sin parámetros.

Resultado: dynamic / Any.

Durante la llamada:

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

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

case "getarstatus": return new InjectionValue(bridge.GetAutoReconnect());

UO.GetAlive

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

Firmas de C#

int UO.GetAlive();
int UO.GetAlive(object? value);

Comprueba la presencia de un objeto sin signos de muerte.

Parámetros

value: objeto opcional en los formularios que se muestran: serial por número/cadena hexadecimal, self, lasttarget o nombre registrado AddObject. Esto no es type. Sin argumentos, lea self. El texto desconocido en algunos formularios provoca un error de conversión; Verifique el nombre antes de llamar.

Valor devuelto

Bandera numérica int: 1 (condición cumplida), 0 (condición no cumplida). Esta es una bandera numérica: en C# verifique el resultado! = 0 o resultado == 0. Comparación directa de int con true/false y si (resultado) no está permitido. 1: el serial positivo existe y no está marcado como muerto. El famoso elemento también indica 1: este no es el filtro mobile. Un objeto muerto/perdido da 0.

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

Lee el modelo local: no abre el destino, no solicita el estado, no cambia la bandera y no envía el paquete. Un objeto destruido se considera perdido incluso antes de que la entrada se elimine del diccionario.
El resultado es una lectura separada. El mundo puede cambiar entre Exists y el próximo desafío; varias consultas no forman una instantánea atómica.

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

1. Comprueba tu propio estado - guión directo

Parámetros y flujo de ejecución:

Los paréntesis vacíos dicen self. activo guarda el resultado una vez; true y false definen dos ramas. Print solo muestra un mensaje de ejemplo.

var active = UO.GetAlive();
if (Truth(Truth(active) == true))
{
    UO.Print("State is active");
}
else
{
    UO.Print("State is inactive or unavailable");
}

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

2. Objeto seleccionado y función completa ReadState - función de script

Parámetros y flujo de ejecución:

lasttarget – objeto previamente seleccionado. Exists comprueba su presencia. obj es el único parámetro ReadState; la función devuelve el resultado del comando sin modificación. Su definición está incluida en el código copiado.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Exists("lasttarget")))
    {
        var observed = ReadState("lasttarget");
        UO.Print("State 1/0: " + Convert.ToString(observed));
    }

    return null;
}

dynamic ReadState(dynamic obj)
{
    return UO.GetAlive(obj);
}

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

3. Observe un cambio en medio segundo - clase de script

Parámetros y flujo de ejecución:

Dos llamadas sin argumentos leen self, UO.Wait(500) establece 500 milisegundos. Se comparan dos imágenes; se pueden omitir las transiciones intermedias. No hay una espera interminable.

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

    async public Task<object?> RunScenarioAsync()
    {
        var before = UO.GetAlive();
        await Delay(500);
        var after = UO.GetAlive();
        if (Truth(before != after))
        {
            UO.Print("State changed: " + Convert.ToString(before) + " -> " + Convert.ToString(after));
        }

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

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

Parámetros: Sin parámetros.

Resultado: int / Integer.

Durante la llamada:

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [GetAlive].
InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Exists: bridge.Exists(serial).
InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::IsDeadState: IsDeadState(serial).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self: bridge.Self.

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.

serial => serial > 0 && bridge.Exists(serial) != 0 && IsDeadState(serial) == 0 ? 1 : 0

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

() => getter(bridge.Self)

Creación de API: Estas funciones registran la API. No se ejecutan de nuevo en cada llamada al comando.

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddState.

`UO.GetAlive(value)` — `UO.GetAlive(Any)`

Parámetros: value (Any)

Resultado: int / Integer.

Durante la llamada:

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [GetAlive].
InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Exists: bridge.Exists(serial).
InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::IsDeadState: IsDeadState(serial).
InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(value).

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.

serial => serial > 0 && bridge.Exists(serial) != 0 && IsDeadState(serial) == 0 ? 1 : 0

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

value => getter(GetObject(value))

Creación de API: Estas funciones registran la API. No se ejecutan de nuevo en cada llamada al comando.

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddState.

UO.GetArmor

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

Firmas de C#

int UO.GetArmor();

Lee el campo de resistencia del personaje actual: armadura física/resistencia.

Parámetros

No hay parámetros.

Valor devuelto

int: valor de estado firmado, -32768..32767 en el modelo de cliente. El valor negativo se mantiene. 0 puede ser una resistencia real, falta de datos o un jugador perdido/destruido; GetResist también da 0 para un selector desconocido. Esto no es un límite bool, ID, de habilidad o resistencia. 1 significa un punto, no éxito.

Comportamiento

El comando no acepta argumentos. Utilice las firmas exactas anteriores.
La lectura del hilo del juego requiere Jugador.PhysicalResistance si el Jugador actual existe y no ha sido destruido; en caso contrario 0. El equipo no se clasifica, las bonificaciones no se recalculan, no se solicita el estado y no hay que esperar actualizaciones. Un fantasma presente no es igual a un Jugador destruido.
PhysicalResistance - campo de armadura/estado del servidor: el servidor clásico puede transmitir la clasificación de armadura y las reglas con resistencias pueden transmitir resistencia física. API no convierte de uno a otro y no calcula el porcentaje de reducción de daño. Armor y los alias físicos leen el mismo campo.
CharacterStatus verifica el cuerpo requerido antes de cambiar el nombre, la salud y las características propias, luego traduce cada palabra de resistencia a un Int16 firmado. Un cuerpo obligatorio recortado no modifica los datos anteriores. La cola opcional type 6 conserva las mismas reglas; Los comandos de resistencia no leen los límites máximos.
Cada llamada lee los datos locales de nuevo. La variable almacena la instantánea; las lecturas individuales pueden recibir diferentes actualizaciones del servidor. Un resultado distinto de cero no prueba la conexión. Cero puede ser un valor o ningún dato.
Estas funciones registran la API. No se ejecutan de nuevo en cada llamada al 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.

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

1. Imprimir valor guardado - script directo

Parámetros y flujo de ejecución:

El valor almacena el resultado de una llamada. Convertir.ToString formatea el número del registro. No hay argumentos: puedes leer tu propio personaje.

var value = UO.GetArmor();
UO.Print("PhysicalResistance: " + Convert.ToString(value));

2. Comparar dos imágenes - función de script

Parámetros y flujo de ejecución:

Entre antes y después hay UO.Wait(500) milisegundos; la diferencia puede ser negativa. Es posible que se pierdan actualizaciones provisionales. La pausa se refiere al ejemplo, no al retraso API.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.GetArmor();
    await Delay(500);
    var after = UO.GetArmor();
    var difference = after - before;
    UO.Print("Resistance change: " + Convert.ToString(difference));
    return null;
}

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

3. Función de prueba de resistencia mínima completa: clase de script

Parámetros y flujo de ejecución:

mínimo=50 es un ejemplo de requisito, no de límite de clientes. ResistanceAtLeast rechaza al jugador que falta, lee un valor y devuelve bool: true o false si el valor >= mínimo. La resistencia en sí no es bool. La función se declara completamente a continuació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()
    {
        if (Truth(Truth(ResistanceAtLeast(50)) == true))
        {
            UO.Print("Local resistance requirement met");
        }
        else
        {
            UO.Print("Requirement not met or no player");
        }

        return null;
    }

    dynamic ResistanceAtLeast(dynamic minimum)
    {
        if (Truth(UO.Self() == 0))
        {
            return false;
        }

        var value = UO.GetArmor();
        return value >= minimum;
    }

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

Parámetros: Sin parámetros.

Resultado: int / Integer.

Durante la llamada:

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.

() => bridge.Armor

Creación de API: Estas funciones registran la API. No se ejecutan de nuevo en cada llamada al comando.

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddInteger.

UO.GetColdResist

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

Firmas de C#

int UO.GetColdResist();

Lee el campo de resistencia del personaje actual: frío.

Parámetros

No hay parámetros.

Valor devuelto

int: valor de estado firmado, -32768..32767 en el modelo de cliente. El valor negativo se mantiene. 0 puede ser una resistencia real, falta de datos o un jugador perdido/destruido; GetResist también da 0 para un selector desconocido. Esto no es un límite bool, ID, de habilidad o resistencia. 1 significa un punto, no éxito.

Comportamiento

El comando no acepta argumentos. Utilice las firmas exactas anteriores.
La lectura del hilo del juego requiere Jugador.ColdResistance si el Jugador actual existe y no ha sido destruido; en caso contrario 0. El equipo no se clasifica, las bonificaciones no se recalculan, no se solicita el estado y no hay que esperar actualizaciones. Un fantasma presente no es igual a un Jugador destruido.
Los campos elementales vienen en formato extendido CharacterStatus (0x11), type >= 4. El comando en sí no verifica la época del servidor. El estado compacto/antiguo sin estos campos deja el caché anterior; El nuevo jugador es inicialmente 0. La resistencia al veneno no es una bandera Poisoned; Tampoco es una habilidad de resistencia a hechizos.
CharacterStatus verifica el cuerpo requerido antes de cambiar el nombre, la salud y las características propias, luego traduce cada palabra de resistencia a un Int16 firmado. Un cuerpo obligatorio recortado no modifica los datos anteriores. La cola opcional type 6 conserva las mismas reglas; Los comandos de resistencia no leen los límites máximos.
Cada llamada lee los datos locales de nuevo. La variable almacena la instantánea; las lecturas individuales pueden recibir diferentes actualizaciones del servidor. Un resultado distinto de cero no prueba la conexión. Cero puede ser un valor o ningún dato.
Estas funciones registran la API. No se ejecutan de nuevo en cada llamada al 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.

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

1. Imprimir valor guardado - script directo

Parámetros y flujo de ejecución:

El valor almacena el resultado de una llamada. Convertir.ToString formatea el número del registro. No hay argumentos: puedes leer tu propio personaje.

var value = UO.GetColdResist();
UO.Print("ColdResistance: " + Convert.ToString(value));

2. Comparar dos imágenes - función de script

Parámetros y flujo de ejecución:

Entre antes y después hay UO.Wait(500) milisegundos; la diferencia puede ser negativa. Es posible que se pierdan actualizaciones provisionales. La pausa se refiere al ejemplo, no al retraso API.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.GetColdResist();
    await Delay(500);
    var after = UO.GetColdResist();
    var difference = after - before;
    UO.Print("Resistance change: " + Convert.ToString(difference));
    return null;
}

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

3. Función de prueba de resistencia mínima completa: clase de script

Parámetros y flujo de ejecución:

mínimo=50 es un ejemplo de requisito, no de límite de clientes. ResistanceAtLeast rechaza al jugador que falta, lee un valor y devuelve bool: true o false si el valor >= mínimo. La resistencia en sí no es bool. La función se declara completamente a continuació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()
    {
        if (Truth(Truth(ResistanceAtLeast(50)) == true))
        {
            UO.Print("Local resistance requirement met");
        }
        else
        {
            UO.Print("Requirement not met or no player");
        }

        return null;
    }

    dynamic ResistanceAtLeast(dynamic minimum)
    {
        if (Truth(UO.Self() == 0))
        {
            return false;
        }

        var value = UO.GetColdResist();
        return value >= minimum;
    }

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

Parámetros: Sin parámetros.

Resultado: int / Integer.

Durante la llamada:

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [GetColdResist].
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.ColdResistance: bridge.ColdResistance.

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.

() => bridge.ColdResistance

Creación de API: Estas funciones registran la API. No se ejecutan de nuevo en cada llamada al comando.

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddInteger.

UO.GetDead

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

Firmas de C#

int UO.GetDead();
int UO.GetDead(object? value);

Comprueba la muerte del personaje.

Parámetros

value: objeto opcional en los formularios que se muestran: serial por número/cadena hexadecimal, self, lasttarget o nombre registrado AddObject. Esto no es type. Sin argumentos, lea self. El texto desconocido en algunos formularios provoca un error de conversión; Verifique el nombre antes de llamar.

Valor devuelto

Bandera numérica int: 1 (condición cumplida), 0 (condición no cumplida). Esta es una bandera numérica: en C# verifique el resultado! = 0 o resultado == 0. Comparación directa de int con true/false y si (resultado) no está permitido. 1 - mobile tiene IsDead, 0 no tiene signo o mobile está ausente. HP=0 por sí solo no significa muerte.

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

Lee el modelo local: no abre el destino, no solicita el estado, no cambia la bandera y no envía el paquete. Un objeto destruido se considera perdido incluso antes de que la entrada se elimine del diccionario.
El resultado es una lectura separada. El mundo puede cambiar entre Exists y el próximo desafío; varias consultas no forman una instantánea atómica.

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

1. Comprueba tu propio estado - guión directo

Parámetros y flujo de ejecución:

Los paréntesis vacíos dicen self. activo guarda el resultado una vez; true y false definen dos ramas. Print solo muestra un mensaje de ejemplo.

var active = UO.GetDead();
if (Truth(Truth(active) == true))
{
    UO.Print("State is active");
}
else
{
    UO.Print("State is inactive or unavailable");
}

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

2. Objeto seleccionado y función completa ReadState - función de script

Parámetros y flujo de ejecución:

lasttarget – objeto previamente seleccionado. Exists comprueba su presencia. obj es el único parámetro ReadState; la función devuelve el resultado del comando sin modificación. Su definición está incluida en el código copiado.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Exists("lasttarget")))
    {
        var observed = ReadState("lasttarget");
        UO.Print("State 1/0: " + Convert.ToString(observed));
    }

    return null;
}

dynamic ReadState(dynamic obj)
{
    return UO.GetDead(obj);
}

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

3. Observe un cambio en medio segundo - clase de script

Parámetros y flujo de ejecución:

Dos llamadas sin argumentos leen self, UO.Wait(500) establece 500 milisegundos. Se comparan dos imágenes; se pueden omitir las transiciones intermedias. No hay una espera interminable.

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

    async public Task<object?> RunScenarioAsync()
    {
        var before = UO.GetDead();
        await Delay(500);
        var after = UO.GetDead();
        if (Truth(before != after))
        {
            UO.Print("State changed: " + Convert.ToString(before) + " -> " + Convert.ToString(after));
        }

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

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

Parámetros: Sin parámetros.

Resultado: int / Integer.

Durante la llamada:

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.

IsDeadState

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

() => getter(bridge.Self)

Creación de API: Estas funciones registran la API. No se ejecutan de nuevo en cada llamada al comando.

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddState.

`UO.GetDead(value)` — `UO.GetDead(Any)`

Parámetros: value (Any)

Resultado: int / Integer.

Durante la llamada:

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.

IsDeadState

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

value => getter(GetObject(value))

Creación de API: Estas funciones registran la API. No se ejecutan de nuevo en cada llamada al comando.

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddState.

UO.GetDex

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

Firmas de C#

int UO.GetDex();
int UO.GetDex(object? objID);

Lee la agilidad actual (Dexterity, DEX) del personaje.

Parámetros

objID: ObjID en el formato que se muestra únicamente, con un argumento: serial número de carácter, cadena decimal/0x hexadecimal, "self", "lasttarget" o nombre AddObject. Selecciona un objeto distinto de graphic/type. Sin argumento, se lee el carácter actual.

Valor devuelto

int — puntos de estadísticas actuales, 0...65535 en el modelo del cliente; no porcentaje, ID, habilidad, modo de bloqueo o bool. 0 también significa carácter faltante/eliminado u objeto inaccesible. Compare con el requisito numérico, no == true. Este no es un límite de estadísticas ni un valor base garantizado sin modificadores.

Comportamiento

Se admiten () para self y (ObjID) para un objeto explícito. No hay otros argumentos opcionales.
Lee Player.Dexterity si Player existe y no ha sido destruido; en caso contrario 0. Un personaje muerto presente no es un objeto eliminado. La estadística no se calcula a partir de HP, maná o resistencia.
GetStr/GetInt/GetDex acepta ObjID. Los datos de PlayerMobile solo están disponibles para self; para otro serial - 0, incluso para mobile cargado. Las características de otra persona no se sustituyen ni se adivinan.
Invoca lecturas en la transmisión del juego con la capacidad de cancelar la espera mediante script. No consulta el estado, no abre el destino, no envía un paquete, no cambia la característica y no agrega retraso.
Cada llamada lee los datos locales de nuevo. La variable almacena la instantánea; las lecturas individuales pueden recibir diferentes actualizaciones del servidor. Un resultado distinto de cero no prueba la conexión. Cero puede ser un valor o ningún dato.
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.Dex(), UO.Dexterity(), UO.GetDex(), UO.GetDexterity().
ExecuteClientApiCompatibility.Arg primero resuelve el nombre del objeto y luego convierte el número. Una cadena no numérica desconocida provoca un error de conversión, no un destino. double se reduce a int, Array/void se reduce a 0. Para seleccionar un personaje, use el serial correcto, no tales transformaciones.

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

1. Leer y mostrar puntos: guión directo

Parámetros y flujo de ejecución:

el valor almacena el resultado numérico; Convertir.ToString simplemente lo formatea para la revista. No hay argumentos ni acciones de personajes.

var value = UO.GetDex();
UO.Print("Dexterity: " + Convert.ToString(value));

2. Comparar dos imágenes - función de script

Parámetros y flujo de ejecución:

antes y después separados 1000 ms; UO.Wait agregado al ejemplo. cambio=después-antes puede ser positivo, cero o negativo. Por sí solo, no distingue entre todas las actualizaciones intermedias y la salida del mundo.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.GetDex();
    await Delay(1000);
    var after = UO.GetDex();
    var change = after - before;
    UO.Print("Change: " + Convert.ToString(change));
    return null;
}

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

3. Función de validación de requisitos completa: clase de secuencia de comandos

Parámetros y flujo de ejecución:

mínimo=80 es un ejemplo de requisito, no de límite de clientes. AttributeAtLeast(mínimo) rechaza el carácter faltante, lee la característica una vez y devuelve bool: true o false si >= mínimo. El significado lógico lo da la comparación, no la característica en sí.

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(AttributeAtLeast(80)) == true))
        {
            UO.Print("Requirement met");
        }
        else
        {
            UO.Print("Requirement not met or no player");
        }

        return null;
    }

    dynamic AttributeAtLeast(dynamic minimum)
    {
        if (Truth(UO.Self() == 0))
        {
            return false;
        }

        var value = UO.GetDex();
        return value >= minimum;
    }

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

4. Seleccione el carácter por serial y el nombre del objeto - script directo

Parámetros y flujo de ejecución:

id es el resultado de UO.Self(), no de type. AddObject almacena ID como statSubject sin alcance porque se especifica el segundo argumento. Ambas llamadas seleccionan el mismo carácter, pero las lecturas no son atómicas.

var id = UO.Self();
if (Truth(id != 0))
{
    UO.AddObject("statSubject", id);
    var direct = UO.GetDex(id);
    var byName = UO.GetDex("statSubject");
    UO.Print("Direct: " + Convert.ToString(direct) + "; alias: " + Convert.ToString(byName));
}

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

Parámetros: Sin parámetros.

Resultado: int / Integer.

Durante la llamada:

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.

() => bridge.Dexterity

Creación de API: Estas funciones registran la API. No se ejecutan de nuevo en cada llamada al comando.

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddInteger.

`UO.GetDex(objID)` — `UO.GetDex(Any)`

Parámetros: objID (Any)

Resultado: int / Integer.

Durante la llamada:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetDexterity: bridge.GetDexterity(Arg(0)).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Dexterity: bridge.Dexterity.

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

case "getdex": return new InjectionValue(arguments.Length > 0 ? bridge.GetDexterity(Arg(0)) : bridge.Dexterity);

UO.GetDexterity

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

Firmas de C#

int UO.GetDexterity();

Lee la agilidad actual (Dexterity, DEX) del personaje.

Parámetros

No hay parámetros.

Valor devuelto

int — puntos de estadísticas actuales, 0...65535 en el modelo del cliente; no porcentaje, ID, habilidad, modo de bloqueo o bool. 0 también significa carácter faltante/eliminado u objeto inaccesible. Compare con el requisito numérico, no == true. Este no es un límite de estadísticas ni un valor base garantizado sin modificadores.

Comportamiento

El comando no acepta argumentos. Utilice las firmas exactas anteriores.
Lee Player.Dexterity si Player existe y no ha sido destruido; en caso contrario 0. Un personaje muerto presente no es un objeto eliminado. La estadística no se calcula a partir de HP, maná o resistencia.
GetStr/GetInt/GetDex acepta ObjID. Los datos de PlayerMobile solo están disponibles para self; para otro serial - 0, incluso para mobile cargado. Las características de otra persona no se sustituyen ni se adivinan.
Invoca lecturas en la transmisión del juego con la capacidad de cancelar la espera mediante script. No consulta el estado, no abre el destino, no envía un paquete, no cambia la característica y no agrega retraso.
Cada llamada lee los datos locales de nuevo. La variable almacena la instantánea; las lecturas individuales pueden recibir diferentes actualizaciones del servidor. Un resultado distinto de cero no prueba la conexión. Cero puede ser un valor o ningún dato.
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.Dex(), UO.Dexterity(), UO.GetDex(), UO.GetDexterity().

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

1. Leer y mostrar puntos: guión directo

Parámetros y flujo de ejecución:

el valor almacena el resultado numérico; Convertir.ToString simplemente lo formatea para la revista. No hay argumentos ni acciones de personajes.

var value = UO.GetDexterity();
UO.Print("Dexterity: " + Convert.ToString(value));

2. Comparar dos imágenes - función de script

Parámetros y flujo de ejecución:

antes y después separados 1000 ms; UO.Wait agregado al ejemplo. cambio=después-antes puede ser positivo, cero o negativo. Por sí solo, no distingue entre todas las actualizaciones intermedias y la salida del mundo.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.GetDexterity();
    await Delay(1000);
    var after = UO.GetDexterity();
    var change = after - before;
    UO.Print("Change: " + Convert.ToString(change));
    return null;
}

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

3. Función de validación de requisitos completa: clase de secuencia de comandos

Parámetros y flujo de ejecución:

mínimo=80 es un ejemplo de requisito, no de límite de clientes. AttributeAtLeast(mínimo) rechaza el carácter faltante, lee la característica una vez y devuelve bool: true o false si >= mínimo. El significado lógico lo da la comparación, no la característica en sí.

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(AttributeAtLeast(80)) == true))
        {
            UO.Print("Requirement met");
        }
        else
        {
            UO.Print("Requirement not met or no player");
        }

        return null;
    }

    dynamic AttributeAtLeast(dynamic minimum)
    {
        if (Truth(UO.Self() == 0))
        {
            return false;
        }

        var value = UO.GetDexterity();
        return value >= minimum;
    }

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

Parámetros: Sin parámetros.

Resultado: int / Integer.

Durante la llamada:

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.

() => bridge.Dexterity

Creación de API: Estas funciones registran la API. No se ejecutan de nuevo en cada llamada al comando.

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddInteger.

UO.GetEnergyResist

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

Firmas de C#

int UO.GetEnergyResist();

Lee el campo de resistencia del personaje actual: energía.

Parámetros

No hay parámetros.

Valor devuelto

int: valor de estado firmado, -32768..32767 en el modelo de cliente. El valor negativo se mantiene. 0 puede ser una resistencia real, falta de datos o un jugador perdido/destruido; GetResist también da 0 para un selector desconocido. Esto no es un límite bool, ID, de habilidad o resistencia. 1 significa un punto, no éxito.

Comportamiento

El comando no acepta argumentos. Utilice las firmas exactas anteriores.
La lectura del hilo del juego requiere Jugador.EnergyResistance si el Jugador actual existe y no ha sido destruido; en caso contrario 0. El equipo no se clasifica, las bonificaciones no se recalculan, no se solicita el estado y no hay que esperar actualizaciones. Un fantasma presente no es igual a un Jugador destruido.
Los campos elementales vienen en formato extendido CharacterStatus (0x11), type >= 4. El comando en sí no verifica la época del servidor. El estado compacto/antiguo sin estos campos deja el caché anterior; El nuevo jugador es inicialmente 0. La resistencia al veneno no es una bandera Poisoned; Tampoco es una habilidad de resistencia a hechizos.
CharacterStatus verifica el cuerpo requerido antes de cambiar el nombre, la salud y las características propias, luego traduce cada palabra de resistencia a un Int16 firmado. Un cuerpo obligatorio recortado no modifica los datos anteriores. La cola opcional type 6 conserva las mismas reglas; Los comandos de resistencia no leen los límites máximos.
Cada llamada lee los datos locales de nuevo. La variable almacena la instantánea; las lecturas individuales pueden recibir diferentes actualizaciones del servidor. Un resultado distinto de cero no prueba la conexión. Cero puede ser un valor o ningún dato.
Estas funciones registran la API. No se ejecutan de nuevo en cada llamada al 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.

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

1. Imprimir valor guardado - script directo

Parámetros y flujo de ejecución:

El valor almacena el resultado de una llamada. Convertir.ToString formatea el número del registro. No hay argumentos: puedes leer tu propio personaje.

var value = UO.GetEnergyResist();
UO.Print("EnergyResistance: " + Convert.ToString(value));

2. Comparar dos imágenes - función de script

Parámetros y flujo de ejecución:

Entre antes y después hay UO.Wait(500) milisegundos; la diferencia puede ser negativa. Es posible que se pierdan actualizaciones provisionales. La pausa se refiere al ejemplo, no al retraso API.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.GetEnergyResist();
    await Delay(500);
    var after = UO.GetEnergyResist();
    var difference = after - before;
    UO.Print("Resistance change: " + Convert.ToString(difference));
    return null;
}

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

3. Función de prueba de resistencia mínima completa: clase de script

Parámetros y flujo de ejecución:

mínimo=50 es un ejemplo de requisito, no de límite de clientes. ResistanceAtLeast rechaza al jugador que falta, lee un valor y devuelve bool: true o false si el valor >= mínimo. La resistencia en sí no es bool. La función se declara completamente a continuació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()
    {
        if (Truth(Truth(ResistanceAtLeast(50)) == true))
        {
            UO.Print("Local resistance requirement met");
        }
        else
        {
            UO.Print("Requirement not met or no player");
        }

        return null;
    }

    dynamic ResistanceAtLeast(dynamic minimum)
    {
        if (Truth(UO.Self() == 0))
        {
            return false;
        }

        var value = UO.GetEnergyResist();
        return value >= minimum;
    }

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

Parámetros: Sin parámetros.

Resultado: int / Integer.

Durante la llamada:

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [GetEnergyResist].
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.EnergyResistance: bridge.EnergyResistance.

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.

() => bridge.EnergyResistance

Creación de API: Estas funciones registran la API. No se ejecutan de nuevo en cada llamada al comando.

InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddInteger.

ClassicUO — Bad Newbie & C# Scripts IDE

ES UO Topic character

Personaje

Secciones

Todos los comandos del tema

Identidad

Estadísticas

Estado

Resiste

Equipo

Dress / Undress

Arm / Disarm

Mount / Dismount

muñeca de papel

Capas de personajes

Ejemplos sobre el tema.

UO.HP

UO.ObjAtLayer

Partes de la referencia

Referencia completa de comandos

UO.Alive

Firmas de C#

Parámetros

Valor devuelto

Comportamiento

Scripts independientes de C#

Ejemplo sencillo

1. Comprueba tu propio estado - guión directo

2. Objeto seleccionado y función completa ReadState - función de script

3. Observe un cambio en medio segundo - clase de script

Implementación del comando

UO.Alive() — UO.Alive()

UO.Alive(value) — UO.Alive(Any)

UO.Arm

Firmas de C#

Parámetros

Valor devuelto

Comportamiento

Scripts independientes de C#

Ejemplo sencillo

1. Uso directo - guión directo

2. Nombres y modo de consulta: función de secuencia de comandos

3. Script auxiliar completo - Clase de script

Implementación del comando

UO.Arm(name) — UO.Arm(String)

UO.Armor

Firmas de C#

Parámetros

Valor devuelto

Comportamiento

Scripts independientes de C#

Ejemplo sencillo

1. Imprimir valor guardado - script directo

2. Comparar dos imágenes - función de script

3. Función de prueba de resistencia mínima completa: clase de script

Implementación del comando

UO.Armor() — UO.Armor()

UO.CharName

Firmas de C#

Parámetros

Valor devuelto

Comportamiento

Scripts independientes de C#

Ejemplo sencillo

1. Mostrar texto después de iniciar sesión: script directo

2. Agregar texto al mensaje de registro: función de secuencia de comandos

3. Comparar dos instantáneas - clase de escenario

Implementación del comando

UO.CharName() — UO.CharName()

UO.CharTitle

Firmas de C#

Parámetros

Valor devuelto

Comportamiento

Scripts independientes de C#

Ejemplo sencillo

1. Mostrar texto después de iniciar sesión: script directo

2. Agregar texto al mensaje de registro: función de secuencia de comandos

3. Comparar dos instantáneas - clase de escenario

Implementación del comando

UO.CharTitle() — UO.CharTitle()

`UO.Alive()` — `UO.Alive()`

`UO.Alive(value)` — `UO.Alive(Any)`

`UO.Arm(name)` — `UO.Arm(String)`

`UO.Armor()` — `UO.Armor()`

`UO.CharName()` — `UO.CharName()`

`UO.CharTitle()` — `UO.CharTitle()`

`UO.CharacterTitle()` — `UO.CharacterTitle()`

`UO.ColdResist()` — `UO.ColdResist()`

`UO.Dead()` — `UO.Dead()`

`UO.Dead(id)` — `UO.Dead(Any)`

`UO.Dex()` — `UO.Dex()`

`UO.Dexterity()` — `UO.Dexterity()`