Skip to content

ES UO Topic items

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

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

Objetos

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

Propiedades, uso y transferencia de objetos. Serie selecciona un artículo específico; type/graphic selecciona la vista. La transferencia de unidades de pila y la cantidad de artículos transferidos tienen diferentes parámetros.

Secciones

Tema Comandos y explicaciones
Item Properties UO.GetSerial · UO.GetType · UO.GetGraphic · UO.GetColor · UO.GetQuantity · UO.GetName · UO.GetTooltip · UO.ContainerOf · UO.GetParent · UO.GetLayer · UO.IsMovable · UO.GetX · UO.GetY · UO.GetZ
Encontrar artículos UO.FindType · UO.FindTypeEx · UO.FindTypesArrayEx · UO.FindItem · UO.FindAnyType · UO.FindAtCoord · UO.FindList · UO.FindDistance · UO.FindVertical
Usando artículos UO.UseObject · UO.UseType · UO.UseFromGround · UO.UseWorldObject · UO.UseItemOnMobile
Moving Artículos UO.Grab · UO.Drag · UO.Drop · UO.MoveItem · UO.MoveItems · UO.MassMove · UO.EmptyContainer
Ground Artículos UO.GetWorldItems · UO.FindType · UO.CountGround · UO.MoveItem
Artículos de contenedor UO.GetContent · UO.FindTypeEx · UO.OpenContainer
Artículos falsos/de clientes UO.MakeFakeItem · UO.DeleteObject
Dye UO.Dye

Todos los comandos del tema

Propiedades del artículo

UO.Exists · UO.IsObjectExists · UO.GetSerial · UO.GetType · UO.GetGraphic · UO.GetColor · UO.GetQuantity · UO.Name · UO.GetName · UO.GetAltName · UO.GetTooltip · UO.GetTooltipRec · UO.GetLayer · UO.GetLocked · UO.IsMovable · UO.GetFlags · UO.ReceiveObjectName · UO.UpdateObject

Usando artículos

UO.UseObject · UO.UseType · UO.UseFromGround · UO.UseWorldObject · UO.UseItemOnMobile · UO.ClickOnObject · UO.TicksUse

Moving Artículos

UO.Grab · UO.Drag · UO.DragItem · UO.Drop · UO.DropHere · UO.DropItem · UO.MoveItem · UO.MoveItems · UO.MassMove · UO.EmptyContainer · UO.DropDelay · UO.DropCheckCoord · UO.Picking

Artículos falsos/de cliente

UO.MakeFakeItem · UO.DeleteObject

Dye

UO.Dye

Objetos almacenados

UO.AddObject · UO.AddType · UO.EasyObject · UO.UserObject · UO.LastObject · UO.Forget

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

Parámetros, resultado y todos los escenarios

var ok = UO.MoveItem("loot");
UO.Print("Move request: " + Convert.ToString(ok));

UO.MassMove

Parámetros, resultado y todos los escenarios

UO.MassMove(350, 0);
UO.Print("Drag one sample item to the destination container");

Partes de la referencia

1 · 2

Referencia completa de comandos

UO.AddObject

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

Firmas de C#

void UO.AddObject(object? name);
void UO.AddObject(object? name, object? objectRawId);

Almacena un objeto serial con nombre para que los scripts lo utilicen más adelante. La forma de dos argumentos especifica el objeto inmediatamente; un argumento desencadena la selección de un objeto por el cursor.

Parámetros

  • name es un nombre no vacío por el cual el objeto estará disponible en tiempo de ejecución.
  • objectRawId — nombre de objeto serial o ya guardado. La sobrecarga de un argumento no acepta este parámetro, sino que solicita la selección de un objeto.

Valor devuelto

void. Verifique el enlace guardado leyendo el objeto por nombre; la llamada no devuelve serial.

Comportamiento

  • Dados dos argumentos, el tiempo de ejecución resuelve objectRawId y almacena serial en name. Con un argumento, el cliente solicita una selección de objeto: se selecciona el elemento o mobile, pero no la celda de la tarjeta. Antes de seleccionar, se elimina el enlace anterior con el mismo nombre; cancelar/perder el cursor no lo restaura.

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

1. Guarde serial de un elemento conocido con un nombre conveniente. - guión directo

Parámetros y flujo de ejecución:

  • Guarde serial de un elemento conocido con un nombre conveniente.
UO.AddObject("supplyBox", "0x40012345");

2. Solicite la selección de un elemento o mobile con el cursor y asígnele el nombre objetivo. - función de guión

Parámetros y flujo de ejecución:

  • Solicite la selección de un elemento o mobile con el cursor y asígnele el nombre objetivo.
return  RunScenario();
 object? RunScenario()
{
    UO.AddObject("target");
    return null;
}

3. Guardar el nombre nuevamente reemplaza el enlace con un nuevo serial. - clase de guión

Parámetros y flujo de ejecución:

  • Guardar el nombre nuevamente reemplaza el enlace con un nuevo serial.
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 selectedSerial = "0x40012345";
        UO.AddObject("supplyBox", selectedSerial);
        return null;
    }
}

Implementación del comando

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

UO.AddObject(name) — UO.AddObject(String)

Parámetros: name (String)

Resultado: void / Unit.

Durante la llamada:

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

public void AddObject(string name)

        {

            SystemMessage($"What is {name}");

            bridge.AddObject(name);

        }

UO.AddObject(name, objectRawId) — UO.AddObject(Any,Any)

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

Resultado: void / Unit.

Durante la llamada:

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

public void AddObject(InjectionValue name, InjectionValue objectRawId) 

            => ObjectChecked(objectRawId, id => AddObject((string)name, id));

UO.AddType

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

Firmas de C#

void UO.AddType(object? name);
void UO.AddType(object? name, object? @type);

Almacena un nombre descriptivo para el elemento o tipo de gráfico del cuerpo mobile. Por ejemplo, después de UO.AddType("bandage", 0x0E21) puedes buscar o usar vendajes mediante el nombre "vendaje" sin repetir el número type en cada línea. Se trata de configurar un nombre → Mapeo gráfico, no crear un elemento ni recordar un ID específico.

Parámetros

  • name: cadena requerida entre comillas: el nombre de su tipo. Se eliminan los espacios de los bordes, las mayúsculas y minúsculas no importan: "vendaje" y "vendaje" son una entrada. Cadena vacía, nombre numérico, palabra cualquiera, carácter | y los personajes de control están prohibidos. Este es el valor del parámetro, no una nueva variable o comando UO: las llamadas posteriores también requieren comillas.
  • type - Opcional int 0..65535: Gráfico/type, como 0x0E21 o 3617. Se acepta una cadena con un número decimal/hexadecimal o el nombre de un tipo ya guardado; este último copia su número actual, no crea una conexión entre nombres. No se aceptan ID de la forma 0x40001001, número negativo, fracción y nombre desconocido. Si no hay ningún argumento, aparece un cursor de selección: haga clic en el elemento cargado, incluso dentro del contenedor, o mobile. Se guarda el Gráfico del objeto seleccionado; La superficie del suelo y las baldosas estáticas no son adecuadas.

Valor devuelto

void: sin valor de retorno. Escribir en línea aparte, sin var resultado = y sin comparación con true/1. El comando no devuelve el type, serial o el indicador de éxito seleccionado. Al cancelar con el ratón se conserva la entrada anterior; si no había ningún nombre antes, permanece indefinido. La siguiente línea del script se ejecuta después de una cancelación normal, por lo que no active automáticamente la acción asumiendo que el usuario definitivamente ha seleccionado un nuevo elemento.

Comportamiento

  • El formulario AddType(nombre, type) almacena el número inmediatamente, sin cursor y sin acción de red. Una repetición con el mismo nombre reemplaza su tipo. Un valor erróneo no destruye la entrada anterior. El formulario AddType(nombre) está esperando ser seleccionado; Esc, reemplazar el cursor con otra acción o un objetivo inapropiado deja la entrada sin cambios. Detener por la fuerza el script interrumpe la espera y libera solo el cursor que le pertenece.
  • Los nombres de los tipos se mantienen separados de AddObject: la misma palabra podría representar type en FindType y serial en UseObject. AddType("suministro", 0x0E21) por sí solo no hace que UseObject("suministro") sea válido. Para un elemento específico, utilice AddObject/GetSerial; para una familia de elementos: AddType y parámetro type.
  • Los nombres se resuelven en los parámetros type FindType (todos los formularios), FindTypeEx, FindTypesArrayEx, FindList, FindNotoriety, GetWorldItems, UseType, UseFromGround, Count, CountGround, CountEx, EquipT, WaitTargetType, WaitTargetGround y WaitTargetObjectType. En máscaras de tipos GetMobiles/FindAnyType/WaitTarget puedes combinar nombres vía | o matriz; las reglas de notoriedad permanecen separadas. Las palabras humano/cerca y otros filtros FindMobile no se anulan.
  • Solo se guarda el gráfico, sin color, cantidad, contenedor, nombre del elemento, capa o propiedades. Dos artículos del mismo tipo de colores diferentes requieren un color distinto en la búsqueda. La entrada no confirma que el elemento exista actualmente, esté disponible o que el servidor permitirá la acción.

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

1. Levanta una pila de oro encontrada - guión directo

Parámetros y flujo de ejecución:

  • pila_oro - nombre; 0x0EED – Oro gráfico. FindType: -1 - cualquier color, ground - tierra, 2 - radio de búsqueda. Se devuelve la cadena serial o una cadena vacía.
  • MoveItem recibe el serial, 0 encontrado para toda la pila y backpack como destino. Esta es una pila, no todas las pilas del radio. La disponibilidad de la transferencia y el resultado real dependen del servidor; la definición de tipo en sí no contiene nada.
UO.AddType("gold_stack", 0x0EED);
var item = UO.FindType("gold_stack", -1, "ground", 2);
if (Truth(item == ""))
{
    UO.Print("No loaded gold stack within 2 tiles");
    return null;
}
var moved = UO.MoveItem(item, 0, "backpack");
if (Truth(moved == 0))
{
    UO.Print("Move request failed");
}

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

2. Utilice el vendaje sólo cuando tenga poca salud: función de script

Parámetros y flujo de ejecución:

  • El número de cadena 0x0E21 se almacena como int Gráfico. Life/MaxHP compara el carácter HP. FindType busca recursivamente cualquier color en la mochila; -1 en la distancia utiliza un comportamiento de búsqueda estándar.
  • self es el propósito de la aplicación, el vendaje después de FindType es una variable con serial. La cola del objetivo se prepara antes de usar el artículo. El script envía el uso y no afirma que el tratamiento ya se haya completado; Las reglas del temporizador/tratamiento dependen del servidor.
return  RunScenario();
 object? RunScenario()
{
    UO.AddType("bandage", "0x0E21");
    if (Truth(UO.Life() >= UO.MaxHP()))
    {
        return null;
    }

    var bandage = UO.FindType("bandage", -1, "backpack", -1, true);
    if (Truth(bandage == ""))
    {
        UO.Print("No loaded bandages in backpack");
        return null;
    }

    UO.WaitTargetObject("self");
    UO.UseObject(bandage);
    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. Asigne su herramienta al mouse, aplíquela como un procedimiento separado: clase de script

Parámetros y flujo de ejecución:

  • Main contiene solo el nombre, por lo que se abre el cursor. Se guarda el tipo de herramienta, no su ID ni su color. UseSavedTool es un procedimiento independiente normal C#, no un comando integrado.
  • UseType busca una instancia de un tipo guardado de cualquier color en la mochila y la usa; devuelve int serial o 0 si falta. Si el nombre nunca se definió, es un error de argumento, no el resultado de 0. Después de la desasignación, Main no llama a UseSavedTool.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        UO.AddType("my_tool");
        return null;
    }

    void UseSavedTool()
    {
        var used = UO.UseType("my_tool", -1, "backpack");
        if (Truth(used == 0))
        {
            UO.Print("No matching loaded tool in backpack");
        }
    }

    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.AddType(name) — UO.AddType(Any)

Parámetros: name (Any)

Resultado: void / Unit.

Durante la llamada:

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

case "addtype":

                    AddType(arguments);

                    break;

UO.AddType(name, type) — UO.AddType(Any,Any)

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

Resultado: void / Unit.

Durante la llamada:

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

case "addtype":

                    AddType(arguments);

                    break;

UO.ClickOnObject

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

Firmas de C#

void UO.ClickOnObject(object? objID);

Envía un solo clic en un objeto a través de GameActions.SingleClick.

Parámetros

  • objID — Serie del objeto o nombre admitido de self/backpack/lasttarget/objeto guardado; Las cadenas numéricas y las cadenas 0x se resuelven en tiempo de ejecución.

Valor devuelto

void: sin valor de retorno.

Comportamiento

  • Click resuelve el enlace a través de ObjectChecked. ClickOnObject primero usa Arg para serial y llama a Click(int). Esta es una solicitud de firma/información del artículo, no DoubleClick o uso del artículo. La respuesta del servidor llega de forma asincrónica.

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

1. Haga clic en el personaje - guión directo

Parámetros y flujo de ejecución:

  • Se envía un solo clic a self.
UO.ClickOnObject("self");

2. Haga clic en el último objetivo: función de secuencia de comandos

Parámetros y flujo de ejecución:

  • Antes de enviar, se comprueba la existencia local del objetivo.
return  RunScenario();
 object? RunScenario()
{
    var target = UO.LastTarget();
    if (Truth(UO.Exists(target)))
    {
        UO.ClickOnObject(target);
    }

    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. Harán clic en la mochila - clase de guión

Parámetros y flujo de ejecución:

  • Un solo clic en una mochila no la abre como si se hiciera doble clic en ella.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var bag = UO.Backpack();
        if (Truth(bag != 0))
        {
            UO.ClickOnObject(bag);
        }

        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.ClickOnObject(objID) — UO.ClickOnObject(Any)

Parámetros: objID (Any)

Resultado: void / Unit.

Durante la llamada:

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

case "clickonobject": Click(Arg(0)); return InjectionValue.Unit;

UO.DeleteObject

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

Firmas de C#

void UO.DeleteObject(object? name);

Elimina el nombre del objeto almacenado de la tabla de tiempo de ejecución.

Parámetros

  • name - nombre string en la tabla Objetos; Sólo se elimina esta entrada.

Valor devuelto

void: sin valor de retorno.

Comportamiento

  • Cuando se encuentra un nombre, elimina la entrada e imprime una confirmación; Si no hay nombre imprime el mensaje no encontrado. El objeto del servidor y su contenido no se eliminan.

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

1. Eliminar nombre creado - script directo

Parámetros y flujo de ejecución:

  • Sólo se elimina la conexión temporal con el carácter serial.
UO.AddObject("temporary",UO.Self());
UO.DeleteObject("temporary");

2. Nombre faltante: función de secuencia de comandos

Parámetros y flujo de ejecución:

  • Un nombre faltante genera un mensaje de diagnóstico.
return  RunScenario();
 object? RunScenario()
{
    UO.DeleteObject("missing-example-name");
    return null;
}

3. Nombre de la tienda en variable - clase de script

Parámetros y flujo de ejecución:

  • La variable string especifica la entrada exacta que se eliminará.
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 name = "temporary";
        UO.AddObject(name, UO.Self());
        UO.DeleteObject(name);
        return null;
    }
}

Implementación del comando

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

UO.DeleteObject(name) — UO.DeleteObject(String)

Parámetros: name (String)

Resultado: void / Unit.

Durante la llamada:

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

public void DeleteObject(string name)

        {

            if (objects.TryGet(name, out int value))

            {

                objects.Remove(name);

                SystemMessage($"Object {name} has been deleted");

            }

            else

                SystemMessage($"Object {name} not found");

        }

UO.Drag

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

Firmas de C#

int UO.Drag(object? id);
int UO.Drag(object? id, object? amount);
int UO.Drag(object? id, object? amount, object? timeout);
void UO.Drag(object? fromX, object? fromY, object? toX, object? toY);

Levanta un elemento específico al cursor; un formulario separado de cuatro argumentos arrastra el mouse en una ventana de Windows.

Parámetros

  • id — Serie de un elemento/carácter específico: número, cadena hexadecimal/decimal, self/backpack/lasttarget/lastobject/lastcontainer/lastcorpse/finditem/laststatus o nombre guardado AddObject. Esto no es type. El objeto debe estar cargado; marque Exists antes de actuar.
  • amount: número de unidades dentro de una pila. 0 o un valor negativo significa toda la pila; lo positivo está limitado por la cantidad disponible. NO es la cantidad de pilas lo que limita MassMove. Si está ausente, equivale a 0.
  • timeout - Tercer argumento opcional: espere el Picking observado hasta el número especificado de milisegundos; el valor predeterminado es 0. Un valor negativo equivale a 0.
  • fromX: solo formato de cuatro int: la X inicial del mouse en los píxeles de la ventana del cliente.
  • fromY: Y inicial del mouse en los píxeles de la ventana del cliente.
  • toX — La X final del mouse en píxeles.
  • toY — La Y final del mouse en píxeles.

Valor devuelto

Con 1..3 argumentos int: 1 — la solicitud de elevación fue aceptada por el cliente (con tiempo de espera>0 también se observó un cursor ocupado); 0: elevación rechazada o tiempo de espera expiró. Con cuatro argumentos null: sin valor de retorno. Este no es un elemento ID.

Comportamiento

  • Para la transferencia de juegos, la forma preferida es id[,cantidad[,tiempo de espera]] seguido de DropItem o un solo MoveItem.
  • El formulario fromX/fromY/toX/toY utiliza eventos del mouse de Windows: mover, presionar, mover, soltar. No tiene confirmación del servidor y depende del contenido/enfoque real de la ventana.
  • Un cursor ocupado no equivale a una transferencia exitosa al destino. La captura y la liberación son acciones separadas.

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

1. Recoge toda la pila y ponla en tu mochila - guión directo

Parámetros y flujo de ejecución:

  • botín - serial hasta AddObject. cantidad=0 significa toda la pila; -1/-1 establece el lugar automático en el gump.
  • DropItem termina de capturar el mismo tiempo de ejecución. Uno significa que se envió la solicitud, no la confirmación del servidor.
if (Truth(UO.Drag("loot", 0)))
{
    var dropped = UO.DropItem("backpack", -1, -1, 0);
    UO.Print("Drop request: " + Convert.ToString(dropped));
}

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

2. Participe en la pila con espera limitada: función de script

Parámetros y flujo de ejecución:

  • cantidad=10 — hasta diez unidades de una pila; tiempo de espera=500 ms.
  • 44/55: coordenadas dentro de la mochila, no en el mapa. Si no se puede tomar el artículo, no se llama a DropItem.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Drag("loot", 10, 500)))
    {
        var dropped = UO.DropItem("backpack", 44, 55, 0);
    }

    return null;
}

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

3. Verifique las manos ocupadas antes del agarre - clase de guión

Parámetros y flujo de ejecución:

  • Un argumento Drag significa toda la pila y el tiempo de espera =0.
  • Picking comprueba el cursor compartido del cliente. No ejecute dos migraciones independientes al mismo 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()
    {
        if (Truth(UO.Picking() == 0))
        {
            if (Truth(UO.Drag("loot")))
            {
                var dropped = UO.DropItem("backpack", -1, -1, 0);
            }
        }

        return null;
    }

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

4. Cuatro coordenadas del mouse: guión directo

Parámetros y flujo de ejecución:

  • Estos son los píxeles de la ventana: inicio (100,120), final (260,180). No hay serial, cantidad ni tiempo de espera.
  • Úselo sólo cuando los elementos requeridos se encuentren en estos lugares; Para objetos, direccionarlo mediante serial es más confiable.
UO.Drag(100, 120, 260, 180);

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.Drag(id) — UO.Drag(Any)

Parámetros: id (Any)

Resultado: int / Integer.

Durante la llamada:

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

public int Drag(InjectionValue id) => Drag(id, InjectionValue.Zero, InjectionValue.Zero);

UO.Drag(id, amount) — UO.Drag(Any,Any)

Parámetros: id (Any), amount (Any)

Resultado: int / Integer.

Durante la llamada:

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

public int Drag(InjectionValue id, InjectionValue amount) => Drag(id, amount, InjectionValue.Zero);

UO.Drag(id, amount, timeout) — UO.Drag(Any,Any,Any)

Parámetros: id (Any), amount (Any), timeout (Any)

Resultado: int / Integer.

Durante la llamada:

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

public int Drag(InjectionValue id, InjectionValue amount, InjectionValue timeout)

        {

            int serial = GetObject(id);

            if (serial == 0)

                return 0;

            int requestedAmount = NumberConversions.ToInt(amount);

            int timeoutMs = Math.Max(0, NumberConversions.ToInt(timeout));

            int result = bridge.DragItem(serial, requestedAmount);

            if (result == 0 || timeoutMs <= 0)

                return result;



            DateTime deadline = DateTime.UtcNow.AddMilliseconds(timeoutMs);

            do

            {

                if (bridge.Picking() != 0)

                    return 1;

                if (DateTime.UtcNow >= deadline)

                    break;

                bridge.Wait(10);

            }

            while (true);



            SystemMessage($"UO.Drag: item pickup was not observable within {timeoutMs} ms.");

            return 0;

        }

UO.Drag(fromX, fromY, toX, toY) — UO.Drag(Integer,Integer,Integer,Integer)

Parámetros: fromX (Integer), fromY (Integer), toX (Integer), toY (Integer)

Resultado: void / Unit.

Durante la llamada:

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

public void Drag(int fromX, int fromY, int toX, int toY) => bridge.Drag(fromX, fromY, toX, toY);

UO.DragItem

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

Firmas de C#

dynamic UO.DragItem(object? objID, object? count);

Selecciona un elemento específico y lo recuerda durante DropItem este tiempo de ejecución.

Parámetros

  • objID — Serie de un elemento/carácter específico: número, cadena hexadecimal/decimal, self/backpack/lasttarget/lastobject/lastcontainer/lastcorpse/finditem/laststatus o nombre guardado AddObject. Esto no es type. El objeto debe estar cargado; marque Exists antes de actuar.
  • count: número de unidades dentro de una pila. 0 o un valor negativo significa toda la pila; lo positivo está limitado por la cantidad disponible. NO es la cantidad de pilas lo que limita MassMove.

Valor devuelto

int 1 — el cliente aceptó el aumento; 0: artículo no encontrado o PickUp rechazado. ¿Metadatos de compatibilidad object? no significa un tipo de resultado arbitrario. Esto no es serial.

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

  • Ambos argumentos son necesarios. No hay una espera de confirmación incorporada; el formulario Drag(id,cantidad,tiempo de espera) agrega una espera para el Picking local.
  • Después de una captura exitosa, complete la acción DropItem. Un elemento recogido manualmente con el mouse no configura la memoria DragItem de este tiempo de ejecución.

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

1. Levantar toda la pila - script directo

Parámetros y flujo de ejecución:

  • ObjID=botín a través de AddObject, Count=0 es la pila completa.
  • El segundo equipo deja caer el mismo objeto recogido.
if (Truth(UO.DragItem("loot", 0)))
{
    var ok = UO.DropItem("backpack", -1, -1, 0);
}

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

2. Levantar cinco unidades - función de script

Parámetros y flujo de ejecución:

  • Reemplace ObjID con su serial. Count=5 se refiere a unidades de la misma pila.
  • La ubicación 44/55 está dentro de la mochila.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.DragItem(0x40001234, 5)))
    {
        var ok = UO.DropItem("backpack", 44, 55, 0);
    }

    return null;
}

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

3. Mostrar captura fallida: clase de secuencia de comandos

Parámetros y flujo de ejecución:

  • picked — int 1/0.
  • No llame a DropItem después de una captura fallida: el cursor puede pertenecer a otra actividad.
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 picked = UO.DragItem("loot", 0);
        if (Truth(picked == 0))
        {
            UO.Print("Item was not picked up");
        }
        else
        {
            var ok = UO.DropItem("backpack", -1, -1, 0);
        }

        return null;
    }

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

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.DragItem(objID, count) — UO.DragItem(Any,Any)

Parámetros: objID (Any), count (Any)

Resultado: dynamic / Any.

Durante la llamada:

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

case "dragitem": return new InjectionValue(bridge.DragItem(Arg(0), Arg(1)));

UO.Drop

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

Firmas de C#

int UO.Drop(object? @object);
int UO.Drop(object? @object, object? count);
int UO.Drop(object? @object, object? count, object? destination);
dynamic UO.Drop(object? objID, object? count, object? x, object? y, object? z);

Realiza una transferencia completa del elemento especificado, por defecto al suelo debajo del personaje.

Parámetros

  • object — Serie de un elemento/carácter específico: número, cadena hexadecimal/decimal, self/backpack/lasttarget/lastobject/lastcontainer/lastcorpse/finditem/laststatus o nombre guardado AddObject. Esto no es type. El objeto debe estar cargado; marque Exists antes de actuar.
  • objID — Serie de un elemento/carácter específico: número, cadena hexadecimal/decimal, self/backpack/lasttarget/lastobject/lastcontainer/lastcorpse/finditem/laststatus o nombre guardado AddObject. Esto no es type. El objeto debe estar cargado; marque Exists antes de actuar.
  • count: número de unidades dentro de una pila. 0 o un valor negativo significa toda la pila; lo positivo está limitado por la cantidad disponible. NO es la cantidad de pilas lo que limita MassMove. En forma abreviada sin contar es 0.
  • destination - Sólo en el formulario con tres argumentos: Serie del contenedor o nombre del conjunto AddObject; backpack/self/my elige una mochila, receiving/catchbag - SetCatchBag, y sin ella una mochila. lastcontainer/lastobject/lasttarget/lastcorpse/finditem/laststatus son válidos cuando se resuelven en el contenedor correcto. ground o 0 selecciona explícitamente tierra; -1—el mismo selector de mochila. Un nombre desconocido o no especificado provoca un error antes de capturar el elemento. Sin un argumento de destino, se utiliza la mochila.
  • x - Sólo en forma de cinco argumentos: destino del mundo X en la Tierra.
  • y — Mundo Y para forma de cinco argumentos.
  • z — Altura mundial para la forma de cinco argumentos.

Valor devuelto

int 1—solicitud de transferencia completa aceptada por el cliente; 0 - falló. El formulario compatible con cinco argumentos tiene metadatos de object?, pero en realidad también devuelve int 1/0. Esto no es un reinicio del DragItem tomado anteriormente: use DropItem para ello.

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

Comportamiento

  • Se registran formularios con argumentos 1, 2, 3 y 5. No existe ningún formulario con cuatro argumentos.
  • Drop(elemento) mueve toda la pila al suelo debajo de ella; Drop(elemento,recuento) especifica unidades; Drop(artículo,recuento,destino) permite contenedor.
  • Drop(item,count,X,Y,Z) siempre significa tierra. Para un contenedor con coordenadas gump, utilice MoveItem.
  • Se aplican restricciones de elevación, DropCheckCoord y verificación del servidor. El equipo no espera una confirmación de entrega por separado.

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

1. Toda la pila está bajo tus pies: un guión directo

Parámetros y flujo de ejecución:

  • object=botín a través de AddObject, count=0 de forma predeterminada.
  • Destino: el punto actual del personaje en el terreno.
var ok = UO.Drop("loot");

2. Cinco unidades en una mochila - función script

Parámetros y flujo de ejecución:

  • count=5 unidades de una pila; destino=backpack.
  • El tercer argumento aquí es un contenedor, no X.
return  RunScenario();
 object? RunScenario()
{
    var ok = UO.Drop("loot", 5, "backpack");
    return null;
}

3. Punto explícito sobre el terreno: clase de escenario

Parámetros y flujo de ejecución:

  • Reemplace ObjID con su serial; Count=0 pila completa; X/Y/Z=1445/1690/0.
  • Para este formulario, el tercer valor es X. El Drag preliminar no es necesario.
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 ok = UO.Drop(0x40001234, 0, 1445, 1690, 0);
        return null;
    }
}

Implementación del comando

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

UO.Drop(object) — UO.Drop(Any)

Parámetros: object (Any)

Resultado: int / Integer.

Durante la llamada:

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

case "drop":

                    if (arguments.Length > 0)

                        return new InjectionValue(MoveItem(arguments[0], arguments.Length > 1 ? arguments[1] : InjectionValue.Zero, arguments.Length > 2 ? arguments[2] : new InjectionValue("ground")));

                    return InjectionValue.False;

UO.Drop(object, count) — UO.Drop(Any,Any)

Parámetros: object (Any), count (Any)

Resultado: int / Integer.

Durante la llamada:

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

case "drop":

                    if (arguments.Length > 0)

                        return new InjectionValue(MoveItem(arguments[0], arguments.Length > 1 ? arguments[1] : InjectionValue.Zero, arguments.Length > 2 ? arguments[2] : new InjectionValue("ground")));

                    return InjectionValue.False;

UO.Drop(object, count, destination) — UO.Drop(Any,Any,Any)

Parámetros: object (Any), count (Any), destination (Any)

Resultado: int / Integer.

Durante la llamada:

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

case "drop":

                    if (arguments.Length > 0)

                        return new InjectionValue(MoveItem(arguments[0], arguments.Length > 1 ? arguments[1] : InjectionValue.Zero, arguments.Length > 2 ? arguments[2] : new InjectionValue("ground")));

                    return InjectionValue.False;

UO.Drop(objID, count, x, y, z) — UO.Drop(Any,Any,Any,Any,Any)

Parámetros: objID (Any), count (Any), x (Any), y (Any), z (Any)

Resultado: dynamic / Any.

Durante la llamada:

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

case "drop": return new InjectionValue(MoveItemChecked(Arg(0), Arg(1), 0, Arg(2), Arg(3), Arg(4)) ? 1 : 0);

UO.DropCheckCoord

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

Firmas de C#

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

Lee o cambia la verificación del rango de coordenadas al dejar caer objetos al suelo.

Parámetros

  • value: valor opcional: 0 deshabilita, int distinto de cero habilita. Sin argumento, el estado sólo se lee.

Valor devuelto

int 0/1 — estado actual después de una posible grabación; Ambas formas devuelven un número.

Comportamiento

  • MoveItemChecked cuando se asigna a un terreno y la bandera está encendida, rechaza la distancia Chebyshev X/Y mayor que las celdas 2 del personaje. La verificación no cambia las coordenadas y no verifica el permiso del servidor para transferir. Las asignaciones de contenedores no se limitan a esta bandera.

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

1. Leer bandera - guión directo

Parámetros y flujo de ejecución:

  • Leer devuelve la configuración normalizada actual.
var enabled = UO.DropCheckCoord();
UO.Print(Convert.ToString(enabled));

2. Habilitar protección de rango - función de script

Parámetros y flujo de ejecución:

  • Las transferencias terrestres a través de MoveItemChecked ahora están limitadas a dos casillas.
return  RunScenario();
 object? RunScenario()
{
    var enabled = UO.DropCheckCoord(1);
    UO.Print(Convert.ToString(enabled));
    return null;
}

3. Restaurar configuración: clase de secuencia de comandos

Parámetros y flujo de ejecución:

  • El valor original se guarda y se restaura explícitamente.
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 old = UO.DropCheckCoord();
        var temporary = UO.DropCheckCoord(0);
        var restored = UO.DropCheckCoord(old);
        return null;
    }
}

Implementación del comando

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

UO.DropCheckCoord() — UO.DropCheckCoord()

Parámetros: Sin parámetros.

Resultado: dynamic / Any.

Durante la llamada:

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

case "dropcheckcoord":

                    if (arguments.Length > 0) state.DropCheckCoord = Arg(0) != 0 ? 1 : 0;

                    return new InjectionValue(state.DropCheckCoord);

UO.DropCheckCoord(value) — UO.DropCheckCoord(Any)

Parámetros: value (Any)

Resultado: dynamic / Any.

Durante la llamada:

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

case "dropcheckcoord":

                    if (arguments.Length > 0) state.DropCheckCoord = Arg(0) != 0 ? 1 : 0;

                    return new InjectionValue(state.DropCheckCoord);

UO.DropDelay

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

Firmas de C#

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

Lee o cambia el retraso de tiempo de ejecución GrabDelay utilizado por las transferencias de artículos.

Parámetros

  • value — Retraso opcional en milisegundos; límites del puente a 50..10000.

Valor devuelto

Sin argumento int con GrabDelay actual. El formulario de entrada devuelve null, aunque los metadatos de ambos formularios contienen object?.

Comportamiento

  • SetDropDelay y GetDropDelay utilizan Estado. GrabDelay. La configuración especifica el retraso de las transferencias por parte del cliente, en lugar de la confirmación de su finalización por parte del servidor.

Scripts independientes de C#

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

Ejemplo sencillo

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

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

1. Retraso de lectura: guión directo

Parámetros y flujo de ejecución:

  • La lectura devuelve milisegundos.
var ms = UO.DropDelay();
UO.Print(Convert.ToString(ms));

2. Establecer retraso: función de secuencia de comandos

Parámetros y flujo de ejecución:

  • La entrada establece 250 ms.
return  RunScenario();
 object? RunScenario()
{
    UO.DropDelay(250);
    return null;
}

3. Borde inferior - Clase de script

Parámetros y flujo de ejecución:

  • El cero se limita a 50 ms, después de lo cual se restaura a su valor anterior.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var previous = UO.DropDelay();
        UO.DropDelay(0);
        UO.Print(Convert.ToString(UO.DropDelay()));
        UO.DropDelay(previous);
        return null;
    }
}

Implementación del comando

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

UO.DropDelay() — UO.DropDelay()

Parámetros: Sin parámetros.

Resultado: dynamic / Any.

Durante la llamada:

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

case "dropdelay":

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

                    return new InjectionValue(bridge.GetDropDelay());

UO.DropDelay(value) — UO.DropDelay(Any)

Parámetros: value (Any)

Resultado: dynamic / Any.

Durante la llamada:

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

case "dropdelay":

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

                    return new InjectionValue(bridge.GetDropDelay());

UO.DropHere

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

Firmas de C#

int UO.DropHere(object? @object);

Transfiere todo el elemento/pila especificado al suelo en el punto actual del personaje.

Parámetros

  • object — Serie de un elemento/carácter específico: número, cadena hexadecimal/decimal, self/backpack/lasttarget/lastobject/lastcontainer/lastcorpse/finditem/laststatus o nombre guardado AddObject. Esto no es type. El objeto debe estar cargado; marque Exists antes de actuar.

Valor devuelto

int 1 — la solicitud de transferencia fue aceptada por el cliente; 0 - no completado. Esto no es serial ni 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

  • Se ha registrado un formulario con exactamente un argumento. Para parte de la pila, use Drop(item,count) o MoveItem.
  • X/Y/Z se toman del personaje durante la llamada. No se requiere DragItem previo.

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

1. Lanzar un elemento conocido: guión directo

Parámetros y flujo de ejecución:

  • object - serial, reemplazar con real.
  • Toda la pila se transfiere al personaje.
var ok = UO.DropHere(0x40001234);

2. Usar nombre guardado: función de secuencia de comandos

Parámetros y flujo de ejecución:

  • El botín se especifica mediante AddObject.
  • Exists verifica la disponibilidad en lugar del permiso del servidor para migrar.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Exists("loot")))
    {
        var ok = UO.DropHere("loot");
    }

    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. Manejar fallas del cliente: clase de secuencia de comandos

Parámetros y flujo de ejecución:

  • ok — int 1/0.
  • Para confirmar el resultado del servidor, verifique la posición y el contenedor del artículo por separado.
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 ok = UO.DropHere("loot");
        if (Truth(ok == 0))
        {
            UO.Print("Drop request was not accepted");
        }

        return null;
    }

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

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.DropHere(object) — UO.DropHere(Any)

Parámetros: object (Any)

Resultado: int / Integer.

Durante la llamada:

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

case "drophere":

                    if (arguments.Length > 0)

                        return new InjectionValue(MoveItem(arguments[0], arguments.Length > 1 ? arguments[1] : InjectionValue.Zero, new InjectionValue("ground"), new InjectionValue(GetX()), new InjectionValue(GetY()), new InjectionValue(GetZ())));

                    return InjectionValue.False;

UO.DropItem

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

Firmas de C#

dynamic UO.DropItem(object? moveIntoID, object? x, object? y, object? z);

Restablece un elemento previamente recogido exitosamente por Drag/DragItem en el mismo tiempo de ejecución.

Parámetros

  • moveIntoID: destino de serie, backpack o nombre del conjunto AddObject. El número 0 significa tierra. Utilice backpack en lugar de self: este argumento de bajo nivel resuelve self en el serial de un personaje.
  • x — Para un contenedor, colóquelo dentro del chicle (-1/65535 automáticamente); para la tierra - mundo X.
  • y — Para un contenedor, colóquelo dentro del chicle (-1/65535 automáticamente); para la tierra - mundo Y.
  • z — Restablecer altura; en el contenedor normalmente 0, en el suelo el punto Z real.

Valor devuelto

int 1: se ha enviado el reinicio y el cursor está marcado como Caído; 0: no hubo DragItem exitoso, el cursor cambió/no es accesible o la asignación no es válida. ¿Metadatos object? la compatibilidad no cambia este resultado. No es una cantidad o serial.

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

  • Los cuatro argumentos son necesarios. Esta opción no retoma el artículo; Drop y MoveItem realizan un traspaso completo a serial.
  • Se comprueba que es el elemento memorizado por este tiempo de ejecución el que se encuentra retenido. Un artículo tomado por otra persona o tomado con la mano no debe caer accidentalmente.
  • Después del envío, la memoria de captura se borra. La configuración GrabDelay agrega una pausa al flujo del script. Es posible que el servidor falle después del regreso.

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

1. Espacio automático en la mochila - guión directo

Parámetros y flujo de ejecución:

  • MoveIntoID=backpack, X/Y=-1, Z=0.
  • La captura exitosa se verifica antes del lanzamiento.
if (Truth(UO.DragItem("loot", 0)))
{
    var ok = UO.DropItem("backpack", -1, -1, 0);
}

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

2. Espacio dentro del cofre - función de script

Parámetros y flujo de ejecución:

  • El cofre se especifica mediante AddObject. X=60/Y=70 - coordenadas en su gump.
  • cantidad=10 se refiere a Drag, DropItem no tiene su propia cantidad.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Drag("loot", 10)))
    {
        var ok = UO.DropItem("chest", 60, 70, 0);
    }

    return null;
}

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

3. Colóquelo en el suelo debajo del personaje - clase de escenario

Parámetros y flujo de ejecución:

  • MoveIntoID=0 selecciona claramente el terreno.
  • X/Y/Z es el punto mundial, no las coordenadas del contenedor.
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 x = UO.GetX();
        var y = UO.GetY();
        var z = UO.GetZ();
        if (Truth(UO.DragItem("loot", 0)))
        {
            var ok = UO.DropItem(0, x, y, z);
        }

        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.DropItem(moveIntoID, x, y, z) — UO.DropItem(Any,Any,Any,Any)

Parámetros: moveIntoID (Any), x (Any), y (Any), z (Any)

Resultado: dynamic / Any.

Durante la llamada:

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

case "dropitem": return new InjectionValue(bridge.DropDraggedItem(Arg(0), Arg(1), Arg(2), Arg(3)));

UO.Dye

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

Firmas de C#

void UO.Dye(object? dyeObject);
void UO.Dye(object? dyeObject, object? target);

Utiliza el elemento colorante transferido; el segundo argumento preestablece el objeto UO.Wait-target.

Parámetros

  • dyeObject — Serie del objeto o nombre admitido de self/backpack/lasttarget/objeto guardado; Las cadenas numéricas y las cadenas 0x se resuelven en tiempo de ejecución.
  • target - Objeto opcional/serial siguiente objetivo. Sin el segundo argumento, no se fija un nuevo objetivo.

Valor devuelto

void: sin valor de retorno.

Comportamiento

  • La forma de dos argumentos primero llama a WaitTargetObject(objetivo), luego a UseObject(dyeObject). La forma de un argumento sólo utiliza el sujeto. Esto es enviar acciones; El color, el derecho de coloración y el total los determina 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.Dye");
UO.Dye(UO.LastObject());

1. Usar artículo de tinte - Guión directo

Parámetros y flujo de ejecución:

  • Una llamada de un argumento no especifica un objetivo.
var dye = UO.LastObject();
if (Truth(UO.Exists(dye)))
{
    UO.Dye(dye);
}

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

2. Objetivo seleccionado de color: función de secuencia de comandos

Parámetros y flujo de ejecución:

  • Target se coloca antes de hacer doble clic en el tinte.
return  RunScenario();
 object? RunScenario()
{
    var dye = UO.LastObject();
    var target = UO.LastTarget();
    if (Truth(UO.Exists(dye)) && Truth(UO.Exists(target)))
    {
        UO.Dye(dye, target);
    }

    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. Nombres guardados - Clase de script

Parámetros y flujo de ejecución:

  • El ejemplo utiliza los nombres previamente guardados tinte y tela.
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.Exists("dye")) && Truth(UO.Exists("cloth")))
        {
            UO.Dye("dye", "cloth");
        }

        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.Dye(dyeObject) — UO.Dye(Any)

Parámetros: dyeObject (Any)

Resultado: void / Unit.

Durante la llamada:

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

case "dye":

                    if (arguments.Length > 1) bridge.WaitTargetObject(Arg(1));

                    bridge.UseObject(Arg(0, bridge.GetLastObject()));

                    break;

UO.Dye(dyeObject, target) — UO.Dye(Any,Any)

Parámetros: dyeObject (Any), target (Any)

Resultado: void / Unit.

Durante la llamada:

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

case "dye":

                    if (arguments.Length > 1) bridge.WaitTargetObject(Arg(1));

                    bridge.UseObject(Arg(0, bridge.GetLastObject()));

                    break;

UO.EasyObject

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

Firmas de C#

void UO.EasyObject(object? name);
void UO.EasyObject(object? name, object? @object);

Almacena el nombre del objeto sin una consulta de destino interactiva.

Parámetros

  • name: el nombre de la entrada de objetos en tiempo de ejecución, que se resuelve en string.
  • object - Opcional serial/enlace. Sin él, se conserva GetLastObject.

Valor devuelto

void: sin valor de retorno.

Comportamiento

  • State.Objects.Set reemplaza la entrada del nombre. La forma de un argumento utiliza el último objeto utilizado en lugar de LastTarget. Esta rama no comprueba por separado la presencia de un objeto en el mundo.

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.EasyObject");
UO.EasyObject("last-used");

1. Guardar el último objeto - script directo

Parámetros y flujo de ejecución:

  • El nombre se le da al LastObject actual.
UO.EasyObject("last-used");

2. Sálvate a ti mismo - función de script

Parámetros y flujo de ejecución:

  • El formulario de dos argumentos guarda el serial pasado.
return  RunScenario();
 object? RunScenario()
{
    UO.EasyObject("me", UO.Self());
    return null;
}

3. Eliminar entrada temporal: clase de secuencia de comandos

Parámetros y flujo de ejecución:

  • Forget elimina solo la asociación de nombre guardada.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        UO.EasyObject("temporary", UO.Self());
        UO.Forget("temporary");
        return null;
    }
}

Implementación del comando

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

UO.EasyObject(name) — UO.EasyObject(Any)

Parámetros: name (Any)

Resultado: void / Unit.

Durante la llamada:

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

case "easyobject":

                    if (arguments.Length > 1) state.Objects.Set(Text(0), Arg(1));

                    else if (arguments.Length > 0) state.Objects.Set(Text(0), bridge.GetLastObject());

                    break;

UO.EasyObject(name, object) — UO.EasyObject(Any,Any)

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

Resultado: void / Unit.

Durante la llamada:

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

case "easyobject":

                    if (arguments.Length > 1) state.Objects.Set(Text(0), Arg(1));

                    else if (arguments.Length > 0) state.Objects.Set(Text(0), bridge.GetLastObject());

                    break;

UO.EmptyContainer

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

Firmas de C#

int UO.EmptyContainer(object? delay);
int UO.EmptyContainer(object? delay, object? source);
int UO.EmptyContainer(object? delay, object? source, object? destination);

Transfiere todo el contenido directo de un cofre, bolsa o cadáver al contenedor especificado. El primer parámetro es siempre el retraso en milisegundos. Si no se especifica ninguna fuente, aparece un ámbito local: seleccione el contenedor de origen. El destino predeterminado es la mochila del personaje actual.

Parámetros

  • delay — Primer parámetro requerido: retraso entre transferencias, en milisegundos. Por ejemplo 350 - 0,35 segundos. Se utilizan valores enteros; los negativos se reducen a 0. GrabDelay no se agrega por separado a este retraso. La última pausa se guarda para que la siguiente línea no supere la última solicitud.
  • source — Segundo parámetro opcional: serial del contenedor de origen, una cadena numérica/hexadecimal o el nombre del objeto guardado. Se admiten lastobject, lastcontainer, lasttarget, último cadáver, backpack/my. Si falta el parámetro o es igual a 0, aparece una cruz. Seleccione un artículo contenedor o un cadáver; Esc cancela la acción.
  • destination: el tercer parámetro opcional es serial o el nombre guardado del contenedor de destino. backpack/self/my selecciona la mochila del personaje. receiving/catchbag seleccione el contenedor SetCatchBag instalado (o mochila si no está instalado). lastcontainer/lastobject/lasttarget/lastcorpse/finditem/laststatus son válidos si se resuelven en un contenedor accesible. Un alias desconocido o no establecido genera un error. Si no se especifica el parámetro, se utiliza la mochila; la configuración del contenedor receiving no cambia esta elección. El destino debe existir y ser diferente del origen. Ground/0 no es un contenedor de destino válido aquí.

Valor devuelto

int: 1 si la fuente no estaba vacía y se podía enviar una solicitud de transferencia para cada artículo directo seleccionado; 0 cuando el origen está vacío, el alcance se cancela, el destino es incorrecto, se agota el tiempo de espera de descarga o se produce un error de envío parcial/completo. Este es el resultado de las solicitudes de los clientes, no una garantía de vaciado confirmado por el servidor.

Comportamiento

  • Formas exactas: EmptyContainer(retraso), EmptyContainer(retraso, origen), EmptyContainer(retraso, origen, destino). En el chat del juego con el prefijo estándar: ,emptycontainer 350; del guión: UO.EmptyContainer(350).
  • Al apuntar, el comando espera la selección, cancelación o parada de emergencia. El cliente continúa actualizando la imagen y la red. Esc no envía ningún acarreo, no utiliza el objeto antiguo y devuelve 0. Si otra vista reemplaza esta selección, la acción también se cancela.
  • Si el contenido aún no se ha descargado, el cliente abre la fuente y espera hasta 3000 ms para que el servidor responda. El contenido que está oculto al cliente no se puede transferir sin obtener los datos del servidor. Un cofre inaccesible/demasiado lejos o una prohibición de servidor resultarán en una falla en lugar de seleccionar otro contenedor.
  • Después de recibir los datos, se crea una lista de elementos directos. Cada pila se migra en su totalidad, con una solicitud de captura y restablecimiento a la vez. The enclosed bag is carried entirely; its contents are not searched separately. Los elementos nuevos agregados posteriormente no se incluyen en la lista actual.
  • Antes de cada pedido, se vuelve a comprobar que el artículo aún se encuentra en su envase original. No se puede anidar un contenedor dentro de sí mismo o de su propio hijo. Si el cursor está ocupado por otro elemento, el comando no lo restablece en su nombre.
  • Un contenedor de destino faltante no se reemplaza por una mochila. Un resultado de 1 no significa que el servidor haya aceptado todas las acciones: si es necesario, verifique el contenido después de actualizar el servidor. Una parada de emergencia interrumpe la espera; Las acciones ya enviadas no se revierten.
  • Un nombre almacenado desconocido o un formato de argumento no válido provoca un error API en lugar de un retorno 0. Distinga esto de un objeto serial perdido válido: para esto, la operación devuelve 0.

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

1. Seleccione un cofre o cadáver con mira y transfiéralo a la mochila - guión directo

Parámetros y flujo de ejecución:

  • El único parámetro delay=350 especifica el intervalo 350 ms. Falta la fuente, por lo que aparece la mira.
  • También falta el destino: el contenido va a la mochila del personaje. Elija el contenedor/cadáver en sí, no solo un elemento dentro de él.
  • enviado recibe 1 o 0. El significado de 0 combina cancelación, vacío y fracaso; Consulte también la revista para obtener más detalles.
UO.Print("Select a chest or corpse");
var sent = UO.EmptyContainer(350);
if (Truth(sent == 0))
{
    UO.Print("Cancelled, empty, unavailable, or a transfer failed");
}

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

2. De un cofre famoso a una mochila sin alcance - función de script

Parámetros y flujo de ejecución:

  • retraso=350; La fuente es el serial real del cofre, reemplaza el ID aproximado por el tuyo. La vista no aparece.
  • El tercer parámetro no está especificado, por lo que destino=backpack. Todos los tipos de artículos directos y pilas completas se incluyen en el traspaso.
  • Print muestra el resultado del envío del cliente, no la cantidad de elementos ni la confirmación del servidor.
return  RunScenario();
 object? RunScenario()
{
    var source = "0x40001234";
    var sent = UO.EmptyContainer(350, source);
    UO.Print("Client request result: " + Convert.ToString(sent));
    return null;
}

3. Entre dos contenedores seleccionados - clase de script

Parámetros y flujo de ejecución:

  • AddObject con un parámetro le solicita que seleccione un objeto y guarda su nombre. Las dos selecciones se realizan secuencialmente.
  • Ud. EmptyContainer delay=350; fuente=fuente_bolsa; destino=bolsa_destino. El tercer parámetro especifica un bolso específico en lugar de una mochila.
  • Los nombres deben hacer referencia a contenedores diferentes. El AddObject cancelado elimina el significado anterior de su nombre, por lo que la bolsa vieja no se usa accidentalmente.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        UO.Print("Select source");
        UO.AddObject("source_bag");
        UO.Print("Select destination");
        UO.AddObject("destination_bag");
        var sent = UO.EmptyContainer(350, "source_bag", "destination_bag");
        UO.Print("Client request result: " + Convert.ToString(sent));
        return null;
    }
}

4. Desde el último contenedor abierto hasta un cofre determinado: guión directo

Parámetros y flujo de ejecución:

  • delay=500 - intervalo de medio segundo. source=lastcontainer: el último contenedor abierto por el servidor en este cliente.
  • destino - ID explícito de tu pecho; reemplace el ejemplo. lastcontainer y lastobject tienen significados diferentes: el último contenedor abierto y el último objeto utilizado.
  • Antes de comenzar, asegúrese de que la última fuente que abrió fue la que necesita. El carry no abre sus bolsas anidadas de forma recursiva.
var destination = "0x40005678";
UO.EmptyContainer(500, "lastcontainer", destination);

5. Seleccione una fuente visualmente, especifique el destino de antemano - función de script

Parámetros y flujo de ejecución:

  • retraso=350; source=0 llama específicamente al alcance, manteniendo la capacidad de pasar un tercer parámetro.
  • destino=almacenamiento apunta a un cofre previamente guardado. Una vez que selecciona una fuente, el contenido se transfiere allí.
  • Esc devuelve enviado=0 sin envolver. Si el almacenamiento es desconocido o no existe, no se selecciona automáticamente otro contenedor.
return  RunScenario();
 object? RunScenario()
{
    UO.AddObject("storage", "0x40005678");
    var sent = UO.EmptyContainer(350, 0, "storage");
    return null;
}

Implementación del comando

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

UO.EmptyContainer(delay) — UO.EmptyContainer(Any)

Parámetros: delay (Any)

Resultado: int / Integer.

Durante la llamada:

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

case "emptycontainer": return ExecuteEmptyContainer(arguments);

UO.EmptyContainer(delay, source) — UO.EmptyContainer(Any,Any)

Parámetros: delay (Any), source (Any)

Resultado: int / Integer.

Durante la llamada:

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

case "emptycontainer": return ExecuteEmptyContainer(arguments);

UO.EmptyContainer(delay, source, destination) — UO.EmptyContainer(Any,Any,Any)

Parámetros: delay (Any), source (Any), destination (Any)

Resultado: int / Integer.

Durante la llamada:

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

case "emptycontainer": return ExecuteEmptyContainer(arguments);

UO.Exists

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

Firmas de C#

int UO.Exists(object? id);

Comprueba la presencia de un objeto no eliminado en el mundo local del cliente.

Parámetros

  • id — Obligatorio serial/ID de un objeto específico: int, cadena hexadecimal o alias self, backpack, lasttarget, lastobject, lastcontainer, último estado, elemento de búsqueda, último cadáver o nombre AddObject. Esto no es graphic/type. El nombre no especificado se resuelve en 0; el comando no abre ningún objetivo nuevo.

Valor devuelto

int 1 - serial ahora se resuelve en el elemento cargado o mobile. int 0: el cliente desconoce el objeto, lo elimina o no se establece el alias. Esta no es una respuesta del servidor sobre la existencia de un objeto: un elemento fuera del área visible puede existir en el servidor y dar 0 aquí.

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

Comportamiento

  • Se lee el modelo del cliente local; No hay solicitudes al servidor, ni esperas ni movimientos.
  • El resultado se refiere al momento de la lectura. Después de UO.Wait u otra acción, el objeto y sus indicadores pueden cambiar.

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

1. Comprobar si la mochila está disponible - guión directo

Parámetros y flujo de ejecución:

  • El argumento backpack es un alias serial de la mochila de tu propio personaje.
  • 1 no significa que el contenido de la mochila ya haya sido recibido en su totalidad o que haya sido abierta.
var present = UO.Exists("backpack");
if (Truth(present))
{
    UO.Print("Backpack is loaded");
}
else
{
    UO.Print("Backpack 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. Vuelva a verificar guardado serial - función de script

Parámetros y flujo de ejecución:

  • El objetivo almacena el serial específico. El nuevo valor lasttarget no lo reemplazará.
  • Después de la pausa 500 ms, el objeto podría haber desaparecido de la visibilidad, por lo que se realiza nuevamente la verificación.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var target = UO.GetSerial("lasttarget");
    await Delay(500);
    if (Truth(UO.Exists(target)))
    {
        UO.Print(UO.GetName(target));
    }
    else
    {
        UO.Print("Saved target is no longer loaded");
    }

    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. Distinguir el formato ID de la presencia de objetos - clase de script

Parámetros y flujo de ejecución:

  • GetSerial formatea el número 1073746484 como 0x40001234 incluso si no hay ningún objeto.
  • Solo la siguiente verificación informa la presencia de este serial en el mundo local actual.
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 serial = UO.GetSerial("1073746484");
        UO.Print("Serial: " + serial);
        var present = UO.Exists(serial);
        UO.Print("Present 1/0: " + Convert.ToString(present));
        return null;
    }
}

Implementación del comando

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

UO.Exists(id) — UO.Exists(Integer)

Parámetros: id (Integer/String)

Resultado: int / Integer.

Durante la llamada:

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

public int Exists(int id) => bridge.Exists(id);

UO.Exists(id) — UO.Exists(String)

Parámetros: id (Integer/String)

Resultado: int / Integer.

Durante la llamada:

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

public int Exists(string id) => Exists(GetObject(id));

UO.Forget

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

Firmas de C#

void UO.Forget(object? name);

Sin un mensaje, elimina el nombre almacenado de los objetos en tiempo de ejecución.

Parámetros

  • name: el nombre de la entrada que se convierte en string.

Valor devuelto

void: sin valor de retorno.

Comportamiento

  • La rama llama a state.Objects.Remove. A diferencia de DeleteObject, este formulario no imprime una confirmación ni informa que falta un nombre. El objeto del mundo del juego no se elimina.

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

1. Eliminar nombre temporal - script directo

Parámetros y flujo de ejecución:

  • Solo se elimina la asociación del nombre con serial.
UO.EasyObject("temporary",UO.Self());
UO.Forget("temporary");

2. Nombre faltante: función de secuencia de comandos

Parámetros y flujo de ejecución:

  • Se permite un nombre faltante sin mensaje.
return  RunScenario();
 object? RunScenario()
{
    UO.Forget("missing-example-name");
    return null;
}

3. Nombre de la variable - clase de script

Parámetros y flujo de ejecución:

  • La eliminación se refiere a la cadena de nombre exacta.
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 name = "temporary";
        UO.EasyObject(name, UO.Self());
        UO.Forget(name);
        return null;
    }
}

Implementación del comando

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

UO.Forget(name) — UO.Forget(Any)

Parámetros: name (Any)

Resultado: void / Unit.

Durante la llamada:

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

case "forget": if (arguments.Length > 0) state.Objects.Remove(Text(0)); break;

UO.GetAltName

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

Firmas de C#

dynamic UO.GetAltName(object? objID);

Lee el título del personaje conocido por el cliente: por ejemplo, profesión o firma después del nombre.

Parámetros

  • objID: objeto serial/ID obligatorio, no type ni cliloc. Acepta int, cadena decimal/hexadecimal, self, backpack, lasttarget, buscar elemento o nombre AddObject. 0 significa sin objeto.

Valor devuelto

string: texto del campo Título para dispositivos móviles. Cadena vacía si se desconoce el título, el objeto no es un carácter o falta ID. No es serial, un nombre completo ni una serie de propiedades. GetAltName usa el mismo campo que GetTitle.

Comportamiento

  • La llamada en sí lee datos locales, no espera al servidor y no envía un solo clic. Para solicitar un nombre/título, utilice ClickOnObject solo; la respuesta llega de forma asincrónica.
  • También se acepta una cadena vacía para un carácter existente. La verificación Exists responde a otra pregunta: si el objeto está cargado.
  • En esta implementación, el nombre alternativo se asigna al campo Título del personaje.

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

1. Título de tu personaje - guión directo

Parámetros y flujo de ejecución:

  • ObjID=self: carácter del cliente actual.
  • título contiene sólo el título; un campo vacío no significa un error de script.
var title = UO.GetAltName("self");
UO.Print(title);

2. Comprobar carácter seleccionado - función script

Parámetros y flujo de ejecución:

  • ObjID=id — serial del último objetivo. GetName y el título se leen por separado.
  • El destino del elemento no tiene un campo Título y proporcionará una cadena vacía.
return  RunScenario();
 object? RunScenario()
{
    var id = UO.GetSerial("lasttarget");
    if (Truth(UO.Exists(id)))
    {
        var title = UO.GetAltName(id);
        if (Truth(title != ""))
        {
            UO.Print(UO.GetName(id) + " " + title);
        }
    }

    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. Solicitar el nombre antes de leer: clase de script

Parámetros y flujo de ejecución:

  • 350: ejemplo de una pausa en milisegundos después de un solo clic; este no es un parámetro captador.
  • El servidor puede responder más tarde o no transferir el título. Preservar el manejo de cadenas vacías.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var id = UO.GetSerial("lasttarget");
        if (Truth(UO.Exists(id)))
        {
            UO.ClickOnObject(id);
            UO.Wait(350);
            UO.Print(UO.GetAltName(id));
        }

        return null;
    }

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

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.GetAltName(objID) — UO.GetAltName(Any)

Parámetros: objID (Any)

Resultado: dynamic / Any.

Durante la llamada:

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

case "getaltname": return new InjectionValue(bridge.GetAltName(Arg(0)));

UO.GetColor

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

Firmas de C#

string UO.GetColor();
string UO.GetColor(object? id);

Lee el objeto hue y lo formatea como una cadena hexadecimal.

Parámetros

  • id es el Serie/ID del objeto, no graphic/type. Número, cadena hexadecimal, nombre estándar self/backpack/lasttarget/lastobject/lastcontainer/laststatus/finditem/lastcorpse o nombre AddObject. Se debe establecer el alias; La existencia se verifica mediante Exists. El formulario registrado sin argumentos utiliza self.

Valor devuelto

string de la forma "0x0481" - código hue/color, cuatro dígitos hexadecimales después de 0x. Para un objeto faltante, se devuelve "0x0000"; El mismo código ocurre para un artículo sin pintar. El color no es graphic/type ni único serial.

Comportamiento

  • Se leen los últimos datos ya conocidos por el cliente; la solicitud de actualización no se envía al servidor.
  • Un objeto desconocido y una propiedad que aún no se ha recuperado pueden tener un valor nulo/vacío. Marque Exists y las condiciones de una acción en particular.

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

1. Descubra el color del último elemento: guión directo

Parámetros y flujo de ejecución:

  • id=lastobject: último objeto utilizado.
  • El resultado ya es una cadena hexadecimal y no requiere Int2Hex.
var hue = UO.GetColor("lastobject");
UO.Print(hue);

2. Buscar un objeto del mismo color - función de script

Parámetros y flujo de ejecución:

  • type y hue son características diferentes de la muestra; FindType acepta ambas representaciones hexadecimales.
  • coincidencia: se encontró serial o una cadena vacía. El color no reemplaza a type.
return  RunScenario();
 object? RunScenario()
{
    var sample = UO.GetSerial("lastobject");
    if (Truth(UO.Exists(sample)))
    {
        var type = UO.GetGraphic(sample);
        var hue = UO.GetColor(sample);
        var match = UO.FindType(type, hue, "backpack");
        UO.Print(match);
    }

    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. Convierta hue a un número entero para comparar - clase de script

Parámetros y flujo de ejecución:

  • GetColor lee self; Hex2Int convierte texto hexadecimal a int.
  • El nulo hue no indica por sí solo si un personaje está presente en el mundo.
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 hue = UO.Hex2Int(UO.GetColor("self"));
        if (Truth(hue == 0))
        {
            UO.Print("Hue is zero");
        }

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

Parámetros: Sin parámetros.

Resultado: string / String.

Durante la llamada:

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

public string GetColor() => GetColor(new InjectionValue(bridge.Self));

UO.GetColor(id) — UO.GetColor(Any)

Parámetros: id (Any)

Resultado: string / String.

Durante la llamada:

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

public string GetColor(InjectionValue id) => NumberConversions.ToHex((short)bridge.GetColor(GetObject(id)));

UO.GetFlags

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

Firmas de C#

int UO.GetFlags(object? id);

Lee la máscara de bits Entity.Flags de un objeto conocido local.

Parámetros

  • id — Serie del objeto o nombre admitido de self/backpack/lasttarget/objeto guardado; Las cadenas numéricas y las cadenas 0x se resuelven en tiempo de ejecución.

Valor devuelto

int - Entidad.Flags original. La entidad desconocida/faltante devuelve 0; es una máscara, no un resultado lógico.

Comportamiento

  • GetObject resuelve el enlace, luego bridge.World.Get lee Entity.Flags en la transmisión del juego. Un valor nulo podría significar un objeto sin banderas ni modelo; Exists separa estos casos. El comando no solicita una actualización de estado.

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

1. Marcate a ti mismo - guión directo

Parámetros y flujo de ejecución:

  • Se muestra la máscara del personaje actual.
var flags = UO.GetFlags("self");
UO.Print(Convert.ToString(flags));

2. Banderas de destino conocidas: función de secuencia de comandos

Parámetros y flujo de ejecución:

  • La prueba Exists distingue el modelo faltante.
return  RunScenario();
 object? RunScenario()
{
    var id = UO.LastTarget();
    if (Truth(UO.Exists(id)))
    {
        var flags = UO.GetFlags(id);
        UO.Print(Convert.ToString(flags));
    }

    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. Falta serial - clase de script

Parámetros y flujo de ejecución:

  • Un serial nulo generalmente no coincide con una Entidad y devuelve 0.
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 flags = UO.GetFlags(0);
        UO.Print(Convert.ToString(flags));
        return null;
    }
}

Implementación del comando

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

UO.GetFlags(id) — UO.GetFlags(Any)

Parámetros: id (Any)

Resultado: int / Integer.

Durante la llamada:

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

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

UO.GetGraphic

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

Firmas de C#

string UO.GetGraphic();
string UO.GetGraphic(object? id);

Lee el graphic de un elemento o el body de un carácter y lo devuelve en texto hexadecimal.

Parámetros

  • id: serie de un objeto específico o un alias que se puede resolver, por ejemplo, "self", "backpack", "lasttarget" o el nombre guardado por AddObject. El gráfico/type no se transfiere aquí. La forma sin argumentos utiliza self.

Valor devuelto

string de la forma "0x0EED" - objeto gráfico type/body. Este no es un ID/serial único. Para un objeto desconocido, el puente devuelve graphic 0, que tiene el formato "0x0000". El comando no devuelve true/false.

Comportamiento

  • El comando lee los datos locales del cliente. No envía destino y no cambia el objeto en el servidor.
  • El número 0 puede ser un valor de datos válido. Verifique la ausencia de un objeto mediante Exists(serial), y no solo por el valor de su propiedad.

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

1. Verifique type de un elemento encontrado: secuencia de comandos directa

Parámetros y flujo de ejecución:

  • FindType recibe type oro y devuelve serial.
  • GetGraphic(serial) devuelve el texto "0x0EED"; las variables item y graphic tienen significados diferentes.
var item = UO.FindType(0x0EED, -1, "backpack");
if (Truth(item != ""))
{
    var graphic = UO.GetGraphic(item);
    UO.Print("Graphic: " + graphic);
}

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

2. Lee la función de script body de tu personaje

Parámetros y flujo de ejecución:

  • La forma sin argumentos usa self.
  • body es el código para la apariencia del personaje, no su serial.
return  RunScenario();
 object? RunScenario()
{
    var body = UO.GetGraphic();
    UO.Print("Body graphic: " + body);
    return null;
}

3. Pase la lectura graphic a una nueva búsqueda - clase de script

Parámetros y flujo de ejecución:

  • lastobject—muestra; graphic es una cadena hexadecimal que FindType acepta como type.
  • -1 permite cualquier color, backpack especifica el área de búsqueda. sameType es nuevamente serial.
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 graphic = UO.GetGraphic("lastobject");
        var sameType = UO.FindType(graphic, -1, "backpack");
        if (Truth(sameType != ""))
        {
            UO.Print("Matching serial: " + sameType);
        }

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

Parámetros: Sin parámetros.

Resultado: string / String.

Durante la llamada:

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

public string GetGraphics() => GetGraphics(bridge.Self);

UO.GetGraphic(id) — UO.GetGraphic(Integer)

Parámetros: id (Integer/String)

Resultado: string / String.

Durante la llamada:

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

public string GetGraphics(int id) => $"0x{bridge.GetGraphics(id):X4}";

UO.GetGraphic(id) — UO.GetGraphic(String)

Parámetros: id (Integer/String)

Resultado: string / String.

Durante la llamada:

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

public string GetGraphics(string id) => GetGraphics(GetObject(id));

UO.GetLayer

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

Firmas de C#

string UO.GetLayer();
string UO.GetLayer(object? id);

Parámetros

  • id: serie de un objeto específico o un alias que se puede resolver, por ejemplo, "self", "backpack", "lasttarget" o el nombre guardado por AddObject. El gráfico/type no se transfiere aquí. La forma sin argumentos utiliza self.

Valor devuelto

string es el nombre de la capa, como "Rhand", "Lhand", "Hat", "Bpack" o "Mount". Se devuelve el primer nombre canónico para el número de capa, por lo que Casco aparece como "Sombrero" y Backpack como "Bpack". Capa 0, elemento desconocido o self indica "No válido". Un número desconocido distinto de cero tiene el formato "0xNN". No es serial, ni graphic, ni la altura Z.

Comportamiento

  • El comando lee los datos locales del cliente. No envía destino y no cambia el objeto en el servidor.
  • El número 0 puede ser un valor de datos válido. Verifique la ausencia de un objeto mediante Exists(serial), y no solo por el valor de su propiedad.

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

1. Determinar la capa de un objeto en la mano derecha - guión directo

Parámetros y flujo de ejecución:

  • ObjAtLayer("Rhand") selecciona un elemento en la mano derecha; 0 significa ranura vacía.
  • GetLayer recibe serial del elemento encontrado y devuelve la cadena "Rhand".
object? item = UO.ObjAtLayer("Rhand");
if (item is string serial)
{
    var layer = UO.GetLayer(serial);
    UO.Print(layer);
}

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

2. Comprobar nombre de capa de mochila: función de secuencia de comandos

Parámetros y flujo de ejecución:

  • id="backpack" — serial de la mochila del personaje actual.
  • Se marca el nombre canónico Bpack, no el alias Backpack.
return  RunScenario();
 object? RunScenario()
{
    var layer = UO.GetLayer("backpack");
    if (Truth(layer == "Bpack"))
    {
        UO.Print("Player backpack layer");
    }
    else
    {
        UO.Print("Layer: " + layer);
    }

    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. Manejar la falta de equipo - Clase de guión

Parámetros y flujo de ejecución:

  • lastobject debe ser un alias real del elemento.
  • No válido significa capa cero. Esto en sí mismo no prueba que falte el artículo: el artículo en la bolsa tampoco está equipado.
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 layer = UO.GetLayer("lastobject");
        if (Truth(layer == "Invalid"))
        {
            UO.Print("No equipment layer");
        }
        else
        {
            UO.Print("Equipment layer: " + layer);
        }

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

Parámetros: Sin parámetros.

Resultado: string / String.

Durante la llamada:

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

public string GetLayer() => GetLayer(new InjectionValue(bridge.Self));

UO.GetLayer(id) — UO.GetLayer(Any)

Parámetros: id (Any)

Resultado: string / String.

Durante la llamada:

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

public string GetLayer(InjectionValue id) => ConvertLayer(bridge.GetLayer(GetObject(id)));

UO.GetLocked

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

Firmas de C#

int UO.GetLocked(object? id);

Comprueba si hay parálisis mobile.

Parámetros

  • id — Obligatorio serial/ID de un objeto específico: int, cadena hexadecimal o alias self, backpack, lasttarget, lastobject, lastcontainer, último estado, elemento de búsqueda, último cadáver o nombre AddObject. Esto no es graphic/type. El nombre no especificado se resuelve en 0; el comando no abre ningún objetivo nuevo. El argumento es necesario; para usted, pase self.

Valor devuelto

int 1 - cargado mobile tiene el atributo IsParalyzed. int 0: falta el atributo, el objeto no es mobile, desconocido o eliminado. A pesar del nombre Bloqueado, no es un bloqueo de cofre, un elemento asegurado ni ningún motivo por el que no se puede mover. La misma bandera se lee como Paralyzed.

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

Comportamiento

  • Se lee el modelo del cliente local; No hay solicitudes al servidor, ni esperas ni movimientos.
  • El resultado se refiere al momento de la lectura. Después de UO.Wait u otra acción, el objeto y sus indicadores pueden cambiar.
  • A pesar del nombre Bloqueado, no es un bloqueo de cofre, un elemento asegurado ni ningún motivo por el que no se puede mover. Se lee la misma bandera que Paralyzed.

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

1. Comprueba tu propio estado - guión directo

Parámetros y flujo de ejecución:

  • El argumento self selecciona explícitamente su carácter. estado: 1/0 únicamente.
  • A pesar del nombre Bloqueado, no es un bloqueo de cofre, un elemento asegurado ni ningún motivo por el que no se puede mover. Se lee la misma bandera que Paralyzed.
var state = UO.GetLocked("self");
var paralyzed = UO.Paralyzed();
UO.Print("GetLocked: " + Convert.ToString(state));
UO.Print("Paralyzed: " + Convert.ToString(paralyzed));

2. Marque seleccionado mobile - función de script

Parámetros y flujo de ejecución:

  • IsNpc excluye sujeto y objeto desconocido. El objetivo almacena un único serial en lugar de una referencia activa a un lasttarget cambiante.
  • El resultado se refiere al campo IsParalyzed. Los datos se actualizan solo después de que el cliente recibe el estado apropiado.
return  RunScenario();
 object? RunScenario()
{
    var target = UO.GetSerial("lasttarget");
    if (Truth(UO.IsNPC(target)))
    {
        var state = UO.GetLocked(target);
        UO.Print("Selected mobile state 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. Comparar el estado antes y después de la pausa - clase de script

Parámetros y flujo de ejecución:

  • UO.Wait(500): pausa en milisegundos. Después, se comprueba por separado que mobile todavía existe.
  • Se comparan dos fotografías. Es posible que se pierdan los cambios intermedios y esta no es una suscripción continua a los eventos del servidor.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

    async public Task<object?> RunScenarioAsync()
    {
        var target = UO.GetSerial("lasttarget");
        if (Truth(UO.IsNPC(target)))
        {
            var before = UO.GetLocked(target);
            await Delay(500);
            if (Truth(UO.IsNPC(target)))
            {
                var after = UO.GetLocked(target);
                if (Truth(before != after))
                {
                    UO.Print("Flag changed: " + Convert.ToString(before) + " -> " + Convert.ToString(after));
                }
            }
            else
            {
                UO.Print("Mobile left the local world");
            }
        }

        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.GetLocked(id) — UO.GetLocked(Any)

Parámetros: id (Any)

Resultado: int / Integer.

Durante la llamada:

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

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

UO.GetName

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

Firmas de C#

string UO.GetName();
string UO.GetName(object? id);

Lee el nombre de un elemento o personaje conocido por el cliente.

Parámetros

  • id es el Serie/ID del objeto, no graphic/type. Número, cadena hexadecimal, nombre estándar self/backpack/lasttarget/lastobject/lastcontainer/laststatus/finditem/lastcorpse o nombre AddObject. Se debe establecer el alias; La existencia se verifica mediante Exists. El formulario registrado sin argumentos utiliza self.

Valor devuelto

string — nombre del objeto. Un objeto desconocido o un nombre que aún no se ha obtenido da como resultado la cadena vacía "". Esto no es serial, ni type, ni la lista completa de propiedades de la información sobre herramientas.

Comportamiento

  • Se leen los últimos datos ya conocidos por el cliente; la solicitud de actualización no se envía al servidor.
  • Un objeto desconocido y una propiedad que aún no se ha recuperado pueden tener un valor nulo/vacío. Marque Exists y las condiciones de una acción en particular.

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

1. Imprimir nombre del personaje - guión directo

Parámetros y flujo de ejecución:

  • Sin argumento, se utiliza self.
  • El resultado es el texto del nombre, se puede mostrar directamente.
var name = UO.GetName();
UO.Print(name);

2. Nombre de destino desconocido del proceso: función de script

Parámetros y flujo de ejecución:

  • lasttarget: alias del objeto. GetName no abre un nuevo objetivo.
  • Un nombre vacío no prueba la ausencia de un objeto: la información sobre serial sin nombre podría haber estado primero.
return  RunScenario();
 object? RunScenario()
{
    var name = UO.GetName("lasttarget");
    if (Truth(name == ""))
    {
        UO.Print("Name is not available");
    }
    else
    {
        UO.Print("Target: " + name);
    }

    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. Comparar nombre sin distinguir entre mayúsculas y minúsculas - clase de script

Parámetros y flujo de ejecución:

  • ToLowerInvariant convierte la cadena a minúsculas para compararla.
  • El nombre lo establece el servidor y se puede localizar. Para filtrar por tipo de gráfico, utilice FindType/GetGraphic.
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 name = UO.GetName("lastobject");
        if (Truth(Convert.ToString(name) == "gold"))
        {
            UO.Print("Known name matches");
        }

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

Parámetros: Sin parámetros.

Resultado: string / String.

Durante la llamada:

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

public string GetName() => GetName("self");

UO.GetName(id) — UO.GetName(Any)

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

Resultado: string / Any.

Durante la llamada:

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.GetName(id) — UO.GetName(Integer)

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

Resultado: string / String.

Durante la llamada:

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

public string GetName(int id) => bridge.GetName(id);

UO.GetName(id) — UO.GetName(String)

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

Resultado: string / String.

Durante la llamada:

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

public string GetName(string id) => GetName(GetObject(id));

UO.GetQuantity

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

Firmas de C#

int UO.GetQuantity(object? id);

Lee el número de unidades en una pila de artículos.

Parámetros

  • id es el Serie/ID del objeto, no graphic/type. Número, cadena hexadecimal, nombre estándar self/backpack/lasttarget/lastobject/lastcontainer/laststatus/finditem/lastcorpse o nombre AddObject. Se debe establecer el alias; La existencia se verifica mediante Exists. El formulario registrado sin argumentos utiliza self. Para este comando, se requiere identificación.

Valor devuelto

int: campo de importe de un artículo específico. Una pila de unidades 1000 normalmente devuelve 1000; artículo único - 1. Para la incógnita serial y para el personaje, regresa 0. Esta no es la cantidad de elementos secundarios del cofre ni el límite de elementos del comando MassMove.

Comportamiento

  • Se leen los últimos datos ya conocidos por el cliente; la solicitud de actualización no se envía al servidor.
  • Un objeto desconocido y una propiedad que aún no se ha recuperado pueden tener un valor nulo/vacío. Marque Exists y las condiciones de una acción en particular.

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

1. Ver el tamaño de la pila encontrada - script directo

Parámetros y flujo de ejecución:

  • FindType busca oro type de cualquier color en la mochila.
  • el oro contiene un serial, por lo que la cantidad solo se aplica a una pila encontrada.
var gold = UO.FindType(0x0EED, -1, "backpack");
if (Truth(gold != ""))
{
    var amount = UO.GetQuantity(gold);
    UO.Print("Units in this stack: " + Convert.ToString(amount));
}

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

2. Comprobar cantidad mínima - función script

Parámetros y flujo de ejecución:

  • id=muestra: último artículo usado.
  • 50 significa los que están en la pila dada. 50 los artículos individuales no se cuentan aquí.
return  RunScenario();
 object? RunScenario()
{
    var sample = UO.GetSerial("lastobject");
    if (Truth(UO.Exists(sample)))
    {
        if (Truth(UO.GetQuantity(sample) >= 50))
        {
            UO.Print("At least 50 units in this item");
        }
    }

    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. Distinguir el número de pilas de las unidades: clase de escenario

Parámetros y flujo de ejecución:

  • FindCount hace referencia a los resultados de la última búsqueda; GetQuantity - a uno serial.
  • Los números pueden variar mucho. MassMove la cantidad limita artículos completos, incluidas las pilas.
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 = UO.FindType(0x0EED, -1, "backpack");
        var stacks = UO.FindCount();
        if (Truth(item != ""))
        {
            var units = UO.GetQuantity(item);
            UO.Print("Matching items: " + Convert.ToString(stacks));
            UO.Print("Units in selected item: " + Convert.ToString(units));
        }

        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.GetQuantity(id) — UO.GetQuantity(Any)

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

Resultado: int / Any.

Durante la llamada:

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

case "getquantity": return new InjectionValue(bridge.GetQuantity(Arg(0)));

UO.GetQuantity(id) — UO.GetQuantity(Integer)

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

Resultado: int / Integer.

Durante la llamada:

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

public int GetQuantity(int id) => bridge.GetQuantity(id);

UO.GetQuantity(id) — UO.GetQuantity(String)

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

Resultado: int / Integer.

Durante la llamada:

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

public int GetQuantity(string id) => GetQuantity(GetObject(id));

UO.GetSerial

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

Firmas de C#

string UO.GetSerial();
string UO.GetSerial(object? id);

Resuelve el nombre del objeto en su serial y formatea serial como una cadena hexadecimal.

Parámetros

  • id - Cadena opcional: alias estándar, nombre AddObject o texto numérico (decimal/hexadecimal). Sin argumento, se utiliza el serial del personaje actual.

Valor devuelto

string de la forma "0x40001234" es un objeto serial/ID único, ocho dígitos hexadecimales después de 0x. El nombre no resuelto es "0x00000000". Esto no es type. El texto numérico se formatea incluso si no se carga dicho objeto; GetSerial no comprueba por sí mismo Exists.

Comportamiento

  • Los nombres de alias se leen desde el estado actual del script/cliente. La cadena serial almacenada no cambia automáticamente si el alias posteriormente apunta a otro objeto.

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

1. Obtén ID de tu personaje - guión directo

Parámetros y flujo de ejecución:

  • No hay parámetros, se selecciona self.
  • serial — cadena hexadecimal. El valor 0x00000000 significa que no hay carácter serial.
var serial = UO.GetSerial();
UO.Print(serial);

2. Utilice de forma segura el apellido seleccionado: función de secuencia de comandos

Parámetros y flujo de ejecución:

  • id="lasttarget" se resuelve en serial último objetivo.
  • Exists verifica la presencia del objeto, GetName lee su nombre conocido por el cliente.
return  RunScenario();
 object? RunScenario()
{
    var serial = UO.GetSerial("lasttarget");
    if (Truth(UO.Exists(serial)))
    {
        UO.Print(UO.GetName(serial));
    }
    else
    {
        UO.Print("Target is not loaded");
    }

    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. Comparar representaciones numéricas: clase de secuencia de comandos

Parámetros y flujo de ejecución:

  • id es una cadena con serial decimal 1073746484.
  • El resultado 0x40001234 muestra el formato. Este es un ejemplo de número, no crea un objeto y no garantiza su existencia.
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 serial = UO.GetSerial("1073746484");
        UO.Print(serial);
        return null;
    }
}

Implementación del comando

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

UO.GetSerial() — UO.GetSerial()

Parámetros: Sin parámetros.

Resultado: string / String.

Durante la llamada:

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

public string GetSerial() => NumberConversions.ToHex(bridge.Self);

UO.GetSerial(id) — UO.GetSerial(String)

Parámetros: id (String)

Resultado: string / String.

Durante la llamada:

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

public string GetSerial(string id) => NumberConversions.ToHex(GetObject(id));

UO.GetTooltip

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

Firmas de C#

dynamic UO.GetTooltip(object? objID);

Lee el texto de propiedades del objeto terminado de OPL. GetTooltip y GetCliloc son sinónimos.

Parámetros

  • objID: objeto serial/ID obligatorio, no type ni cliloc. Acepta int, cadena decimal/hexadecimal, self, backpack, lasttarget, buscar elemento o nombre AddObject. 0 significa sin objeto.

Valor devuelto

string: nombre y texto de las propiedades, separados por avance de línea, o solo la parte que no está vacía. Cadena vacía si ObjID=0 o si no se reciben propiedades. Este es un texto ya preparado; numérico ID cliloc y los parámetros son devueltos por GetTooltipRec.

Comportamiento

  • Si la entrada ya existe en OPL, su texto se devuelve inmediatamente. Si no hay entrada, se envía una solicitud de propiedad y se espera una respuesta hasta 200 ms con una verificación cada 10 ms. Una pausa no garantiza una respuesta.
  • Necesitamos un objeto accesible y soporte para propiedades por parte del servidor. Un resultado vacío no es prueba de la ausencia del objeto: use Exists solo.
  • El texto puede contener marcas del servidor. No analice propiedades numéricas por posición de línea; use GetTooltipRec para esto.

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

1. Propiedades de un artículo en una mochila - guión directo

Parámetros y flujo de ejecución:

  • FindType: oro 0x0EED, cualquier hue=-1, contenido directo backpack. ObjID=elemento - encontrado serial.
  • El resultado del getter es el texto, no la cantidad de oro. Para cantidad, utilice FindCount(artículo).
var item = UO.FindType(0x0EED, -1, "backpack");
if (Truth(item != ""))
{
    UO.Print(UO.GetTooltip(item));
}

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

2. Manejar sin respuesta: función de secuencia de comandos

Parámetros y flujo de ejecución:

  • ObjID=lasttarget debe apuntar al objeto deseado.
  • Una cadena vacía se procesa por separado; No es necesario repetir automáticamente la solicitud en un bucle sin fin.
return  RunScenario();
 object? RunScenario()
{
    var text = UO.GetTooltip("lasttarget");
    if (Truth(text == ""))
    {
        UO.Print("No properties received");
    }
    else
    {
        UO.Print(text);
    }

    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. Guardar texto hasta la siguiente acción - clase de script

Parámetros y flujo de ejecución:

  • id y save son variables separadas: el ID único del objeto y una instantánea de su texto.
  • guardado no cambiará automáticamente si las propiedades en el servidor cambian más adelante.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var id = UO.GetSerial("lasttarget");
        var saved = UO.GetTooltip(id);
        UO.Print("Object: 0x" + Hex(id));
        UO.Print(saved);
        return null;
    }

    string Hex(object? value) => Convert.ToInt64(value).ToString("X");
}

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.GetTooltip(objID) — UO.GetTooltip(Any)

Parámetros: objID (Any)

Resultado: dynamic / Any.

Durante la llamada:

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

case "getcliloc":

                case "gettooltip":

                    return new InjectionValue(bridge.GetTooltip(Arg(0)));

UO.GetTooltipRec

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

Firmas de C#

dynamic UO.GetTooltipRec(object? objID);

Lee propiedades estructuradas: cliloc ID y parámetros de cada entrada OPL.

Parámetros

  • objID: objeto serial/ID obligatorio, no type ni cliloc. Acepta int, cadena decimal/hexadecimal, self, backpack, lasttarget, buscar elemento o nombre AddObject. 0 significa sin objeto.

Valor devuelto

Array es una instantánea única de las filas de propiedades. Cada línea es igual a [clilocID:int, parámetros:Array]. filas[i][0] es el número del mensaje localizado, filas[i][1] es una matriz de parámetros. ArrayLength(filas) — número de propiedades; ArrayLength(parámetros): el número de parámetros para una propiedad. Una matriz vacía si ObjID=0 o no se reciben registros. Esta no es una lista de elementos ID ni un texto terminado.

Comportamiento

  • La entrada de la caché se devuelve inmediatamente. Si falta OPL, las propiedades se consultan con una espera de hasta 120 ms; cancelar el procedimiento interrumpe la espera. El vacío conocido OPL no provoca anticipación.
  • Las pestañas de servicio iniciales se omiten como en ClilocLoader. Los parámetros internos vacíos guardan posiciones; #El número se guarda como una cadena para su posterior localización. Los parámetros desconocidos producen una matriz vacía.
  • Cambiar la matriz devuelta no cambia la caché del cliente. Para texto utilice GetTooltip/GetCliloc; para traducir una línea - GetClilocByID(clilocID, parámetros).

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

1. Ver todos los números de propiedad - guión directo

Parámetros y flujo de ejecución:

  • ObjID=lasttarget — objeto. las filas contienen propiedades, i es el índice de 0. la fila [0] es cliloc, no serial.
  • El bucle falla en una matriz vacía. Cada registro se procesa una vez.
var rows = UO.GetTooltipRec("lasttarget");
var i = 0;
while (Truth(i < ArrayLength(rows)))
{
    var row = rows[i];
    UO.Print("Cliloc: " + Convert.ToString(row[0]));
    i = i + 1;
}

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;

2. Traducir cada registro con sus parámetros - función script

Parámetros y flujo de ejecución:

  • GetClilocByID recibe clilocID=fila[0] y matriz de sustitución=fila[1].
  • Los parámetros se mantienen en orden. No pase toda la fila en lugar de una serie de parámetros.
return  RunScenario();
 object? RunScenario()
{
    var rows = UO.GetTooltipRec("lasttarget");
    var i = 0;
    while (Truth(i < ArrayLength(rows)))
    {
        var row = rows[i];
        var text = UO.GetClilocByID(row[0], row[1]);
        UO.Print(text);
        i = i + 1;
    }

    return null;
}

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

3. Obtener el parámetro numérico de una propiedad conocida - clase de script

Parámetros y flujo de ejecución:

  • buscado - ejemplo de propiedad ID; reemplácelo con el clicoc deseado. args[0] es el primer parámetro, inicialmente string.
  • Antes de Val, se verifica el número de parámetros y el formato del número. El parámetro puede ser texto o un enlace #cliloc.
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 rows = UO.GetTooltipRec("lasttarget");
        var wanted = 1060401;
        var i = 0;
        while (Truth(i < ArrayLength(rows)))
        {
            var row = rows[i];
            var args = row[1];
            if (Truth(row[0] == wanted) && Truth(ArrayLength(args) > 0))
            {
                if (Truth(IsNumeric(args[0])))
                {
                    UO.Print("Value: " + Convert.ToString(Val(args[0])));
                }
            }

            i = i + 1;
        }

        return null;
    }

    int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
    bool IsNumeric(object? value) => double.TryParse(Convert.ToString(value), System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out _);
    bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
    double Val(object? value) => double.TryParse(Convert.ToString(value), System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out var number) ? number : 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.GetTooltipRec(objID) — UO.GetTooltipRec(Any)

Parámetros: objID (Any)

Resultado: dynamic / Array.

Durante la llamada:

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

case "gettooltiprec":

                    return new InjectionValue(bridge.GetTooltipRecords(Arg(0)).Select(entry =>

                        new InjectionValue(new[]

                        {

                            new InjectionValue(entry.ClilocID),

                            new InjectionValue(entry.Parameters.Select(value => new InjectionValue(value)).ToArray())

                        })).ToArray());

UO.GetType

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

Firmas de C#

dynamic UO.GetType(object? objID);

Lee el numérico graphic de un elemento o body de un carácter.

Parámetros

Valor devuelto

int - graphic/type de un artículo o body de un personaje, por ejemplo 0x0EED (3821) para oro. El valor 0 se devuelve si no se encuentra el objeto. GetType no devuelve serial ni el texto "0x..."; la forma de cadena viene dada por GetGraphic.

Comportamiento

  • El comando lee los datos locales del cliente. No envía destino y no cambia el objeto en el servidor.
  • El número 0 puede ser un valor de datos válido. Verifique la ausencia de un objeto mediante Exists(serial), y no solo por el valor de su propiedad.

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

1. Comparar numérico type con una constante - guión directo

Parámetros y flujo de ejecución:

  • ObjID="lastobject" - alias de un objeto específico.
  • 0x0EED es el número de graphic; La comparación no busca un objeto con tal serial.
var graphic = UO.GetType("lastobject");
if (Truth(graphic == 0x0EED))
{
    UO.Print("Gold graphic");
}

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

2. Obtener type propia mochila - función de script

Parámetros y flujo de ejecución:

  • ObjID="backpack" - mochila actual.
  • Convertir.ToString formatea el número devuelto para su salida.
return  RunScenario();
 object? RunScenario()
{
    var graphic = UO.GetType("backpack");
    UO.Print("Backpack type: " + Convert.ToString(graphic));
    return null;
}

3. Verifique la existencia del objeto antes de leer type - clase de script

Parámetros y flujo de ejecución:

  • La cadena vacía FindType se verifica antes de Exists.
  • Exists devuelve el booleano 1/0; GetType devuelve el número graphic.
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 = UO.FindType(0x0EED, -1, "backpack");
        if (Truth(item != ""))
        {
            if (Truth(UO.Exists(item)))
            {
                UO.Print("Type: " + Convert.ToString(UO.GetType(item)));
            }
        }

        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.GetType(objID) — UO.GetType(Any)

Parámetros: objID (Any)

Resultado: dynamic / Any.

Durante la llamada:

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

case "gettype": return new InjectionValue(bridge.GetGraphics(Arg(0)));

UO.Grab

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

Firmas de C#

int UO.Grab();
int UO.Grab(object? id);
int UO.Grab(object? amount, object? id);
int UO.Grab(object? amount, object? item, object? container);
int UO.Grab(object? amount, object? item, object? container, object? timeout);

Transfiere un artículo al contenedor especificado/receptor o abre la selección de artículos.

Parámetros

  • id — Serie/alias del artículo. Sin argumentos, comienza la selección interactiva; con un argumento exactamente 1 se toma la unidad de este artículo.
  • item — Serie/alias del artículo. Sin argumentos, comienza la selección interactiva; con un argumento exactamente 1 se toma la unidad de este artículo.
  • id / item — Serie/alias del artículo. Sin argumentos, comienza la selección interactiva; con un argumento exactamente 1 se toma la unidad de este artículo.
  • amount - En las formas 2..4 - cantidad como primer argumento, luego artículo. 0 significa toda la pila según las reglas MoveItem; no cambie el pedido con el formulario Grab(item).
  • container - Formularios 3/4 únicamente: asignación explícita. Sin él, indique .ReceivingContainer, si >0, en caso contrario backpack. Las líneas self/my/backpack en el destino significan mochila; ground - tierra.
  • timeout - 4 solo forma, milisegundos. Enviado a CompactMoveItem en espera de confirmación; las coordenadas ground se toman de self, contenedor - 0xFFFF/0xFFFF/0.

Valor devuelto

Bandera numérica int: 1 — selección interactiva aceptada o transferencia aceptada/confirmada según el formulario seleccionado; 0 - falla/artículo no adecuado. Un resultado sin argumentos no significa que el artículo ya haya sido transferido.

Comportamiento

  • CompactGrab conserva la forma histórica Grab(elemento)=1 unidad. Los formularios sin tiempo de espera usan CompactMoveItem sin forzar una espera de confirmación; el formulario con tiempo de espera especifica UO.Wait=true.
  • La serie 0 da inmediatamente 0. Los objetos no resueltos/inapropiados se revisan más a fondo mediante MoveItem. Las reglas del servidor, la cantidad de pila y el contenedor actual afectan el resultado. Tres/cuatro argumentos no son coordenadas de colocación.
  • cantidad<=0 solicita toda la pila. En un formulario con tiempo de espera, una pausa negativa se convierte en 0, pero se realiza al menos una verificación local; entre controles UO.Wait(10). La transferencia parcial se confirma mediante una disminución de la cantidad inicial, la transferencia completa se confirma mediante la asignación y para ground X/Y/Z. Esta es una observación del estado del mundo, no una nueva respuesta protocolaria de la solicitud ID; un estado ya adecuado puede dar 1 inmediatamente. El tiempo de espera indica 0 aunque es posible que la solicitud ya se haya enviado.

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

1. Llamada directa - guión directo

Parámetros y flujo de ejecución:

  • Transfiere un artículo al contenedor especificado/receptor o abre la selección de artículos.
var accepted = UO.Grab();
UO.Print(accepted);

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

Parámetros y flujo de ejecución:

  • CompactGrab conserva la forma histórica Grab(elemento)=1 unidad. Los formularios sin tiempo de espera usan CompactMoveItem sin forzar una espera de confirmación; el formulario con tiempo de espera especifica UO.Wait=true.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Exists("lastobject")))
    {
        UO.Print(UO.Grab("lastobject"));
    }

    return null;
}

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

3. Función auxiliar completa: clase de script

Parámetros y flujo de ejecución:

  • La serie 0 da inmediatamente 0. Los objetos no resueltos/inapropiados se revisan más a fondo mediante MoveItem. Las reglas del servidor, la cantidad de pila y el contenedor actual afectan el resultado. Tres/cuatro argumentos no son coordenadas de colocació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(UO.Exists("lastobject")))
        {
            UO.Print(UO.Grab(0, "lastobject", "backpack", 2000));
        }

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

Parámetros: Sin parámetros.

Resultado: int / Integer.

Durante la llamada:

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

public int Grab() => bridge.RequestInteractiveGrabTarget();

UO.Grab(id) — UO.Grab(Any)

Parámetros: id (Any)

Resultado: int / Integer.

Durante la llamada:

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

public int Grab(InjectionValue id) => CompactGrab(new[] { id });

UO.Grab(amount, id) — UO.Grab(Any,Any)

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

Resultado: int / Any.

Durante la llamada:

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

case "grab": return new InjectionValue(CompactGrab(arguments));

UO.Grab(amount, id) — UO.Grab(Integer,Integer)

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

Resultado: int / Integer.

Durante la llamada:

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

public int Grab(int amount, int id) => CompactGrab(new[] { new InjectionValue(amount), new InjectionValue(id) });

UO.Grab(amount, id) — UO.Grab(Integer,String)

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

Resultado: int / Integer.

Durante la llamada:

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

public int Grab(int amount, string id) => CompactGrab(new[] { new InjectionValue(amount), new InjectionValue(id) });

UO.Grab(amount, id) — UO.Grab(String,String)

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

Resultado: int / Integer.

Durante la llamada:

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

public int Grab(string amount, string id) => CompactGrab(new[] { new InjectionValue(amount), new InjectionValue(id) });

UO.Grab(amount, item, container) — UO.Grab(Any,Any,Any)

Parámetros: amount (Any), item (Any), container (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.

values => new InjectionValue(CompactGrab(values))

UO.Grab(amount, item, container, timeout) — UO.Grab(Any,Any,Any,Any)

Parámetros: amount (Any), item (Any), container (Any), timeout (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.

values => new InjectionValue(CompactGrab(values))

UO.IsMovable

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

Firmas de C#

int UO.IsMovable(object? objID);

Comprueba las señales locales de portabilidad de un artículo conocido utilizando las reglas de selección clásicas UO.

Parámetros

  • objID — Obligatorio serial/ID de un objeto específico: int, cadena hexadecimal o alias self, backpack, lasttarget, lastobject, lastcontainer, último estado, elemento de búsqueda, último cadáver o nombre AddObject. Esto no es graphic/type. El nombre no especificado se resuelve en 0; el comando no abre ningún objetivo nuevo.

Valor devuelto

int 1: el artículo no se retira, no es múltiple y no está bloqueado por la regla local de peso/movimiento para artículos en el suelo. int 0 - mobile, objeto múltiple, desconocido/eliminado u objeto bloqueado en el suelo. 1 no garantiza un Drag/MoveItem exitoso: el rango, el acceso, el estado del cursor y la decisión final del servidor se verifican por separado.

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

Comportamiento

  • Se lee el modelo del cliente local; No hay solicitudes al servidor, ni esperas ni movimientos.
  • El resultado se refiere al momento de la lectura. Después de UO.Wait u otra acción, el objeto y sus indicadores pueden cambiar.
  • En el terreno, un elemento se considera bloqueado cuando el peso de su entrada de datos de mosaico es mayor que 90 y falta la bandera del servidor móvil. Los pesos 90 y menores no requieren esta bandera.
  • Dentro de un contenedor, no se aplica la regla de bloquear un artículo en el suelo. El peso de Tiledata aquí es un atributo de servicio, no GetQuantity ni el peso actual del carácter.
  • Otra documentación del cliente puede tener descripciones de peso diferentes. La regla real de este cliente GameActions.PickUp se describe aquí.

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

1. Verifique el último elemento sin moverse: guión directo

Parámetros y flujo de ejecución:

  • artículo: serial del último artículo utilizado. El número de un bien mueble no es su cantidad.
  • El ejemplo no recoge nada ni envía nada al servidor.
var item = UO.GetSerial("lastobject");
var movable = UO.IsMovable(item);
UO.Print("Locally movable 1/0: " + Convert.ToString(movable));

2. Calcule por separado el signo y la distancia - función de script

Parámetros y flujo de ejecución:

  • Para un elemento en el suelo, GetDistance muestra el alcance conocido del cliente.
  • Incluso con movable=1 el elemento puede estar demasiado lejos. Un resultado positivo no indica permiso del servidor para realizar la transferencia.
return  RunScenario();
 object? RunScenario()
{
    var item = UO.GetSerial("lasttarget");
    if (Truth(UO.Exists(item)))
    {
        var movable = UO.IsMovable(item);
        var distance = UO.GetDistance(item);
        UO.Print("Movable: " + Convert.ToString(movable));
        UO.Print("Distance: " + Convert.ToString(distance));
    }

    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. Verificar toda la pila encontrada - clase de script

Parámetros y flujo de ejecución:

  • FindType selecciona un serial dorado de cualquier color en la mochila.
  • IsMovable verifica todo el artículo. GetQuantity lee el número de unidades por separado; el resultado IsMovable no reemplaza este contador.
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 = UO.FindType(0x0EED, -1, "backpack");
        if (Truth(item != ""))
        {
            if (Truth(UO.IsMovable(item)))
            {
                var units = UO.GetQuantity(item);
                UO.Print("Selected stack units: " + Convert.ToString(units));
            }
        }

        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.IsMovable(objID) — UO.IsMovable(Any)

Parámetros: objID (Any)

Resultado: int / Integer.

Durante la llamada:

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

case "ismovable": return new InjectionValue(bridge.IsMovable(Arg(0)));

UO.IsObjectExists

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

Firmas de C#

int UO.IsObjectExists(object? objID);

Comprueba la presencia de un objeto no eliminado en el mundo local del cliente.

Parámetros

  • objID — Obligatorio serial/ID de un objeto específico: int, cadena hexadecimal o alias self, backpack, lasttarget, lastobject, lastcontainer, último estado, elemento de búsqueda, último cadáver o nombre AddObject. Esto no es graphic/type. El nombre no especificado se resuelve en 0; el comando no abre ningún objetivo nuevo.

Valor devuelto

int 1 - serial ahora se resuelve en el elemento cargado o mobile. int 0: el cliente desconoce el objeto, lo elimina o no se establece el alias. Esta no es una respuesta del servidor sobre la existencia de un objeto: un elemento fuera del área visible puede existir en el servidor y dar 0 aquí.

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

Comportamiento

  • Se lee el modelo del cliente local; No hay solicitudes al servidor, ni esperas ni movimientos.
  • El resultado se refiere al momento de la lectura. Después de UO.Wait u otra acción, el objeto y sus indicadores pueden cambiar.

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

1. Comprobar si la mochila está disponible - guión directo

Parámetros y flujo de ejecución:

  • El argumento backpack es un alias serial de la mochila de tu propio personaje.
  • 1 no significa que el contenido de la mochila ya haya sido recibido en su totalidad o que haya sido abierta.
var present = UO.IsObjectExists("backpack");
if (Truth(present))
{
    UO.Print("Backpack is loaded");
}
else
{
    UO.Print("Backpack 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. Vuelva a verificar guardado serial - función de script

Parámetros y flujo de ejecución:

  • El objetivo almacena el serial específico. El nuevo valor lasttarget no lo reemplazará.
  • Después de la pausa 500 ms, el objeto podría haber desaparecido de la visibilidad, por lo que se realiza nuevamente la verificación.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var target = UO.GetSerial("lasttarget");
    await Delay(500);
    if (Truth(UO.IsObjectExists(target)))
    {
        UO.Print(UO.GetName(target));
    }
    else
    {
        UO.Print("Saved target is no longer loaded");
    }

    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. Distinguir el formato ID de la presencia de objetos - clase de script

Parámetros y flujo de ejecución:

  • GetSerial formatea el número 1073746484 como 0x40001234 incluso si no hay ningún objeto.
  • Solo la siguiente verificación informa la presencia de este serial en el mundo local actual.
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 serial = UO.GetSerial("1073746484");
        UO.Print("Serial: " + serial);
        var present = UO.IsObjectExists(serial);
        UO.Print("Present 1/0: " + Convert.ToString(present));
        return null;
    }
}

Implementación del comando

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

UO.IsObjectExists(objID) — UO.IsObjectExists(Any)

Parámetros: objID (Any)

Resultado: int / Integer.

Durante la llamada:

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

case "isobjectexists": return new InjectionValue(bridge.Exists(Arg(0)));

UO.LastObject

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

Firmas de C#

dynamic UO.LastObject();

Lee el serial del último objeto utilizado.

Parámetros

No hay parámetros.

Valor devuelto

int — guardado serial; 0 significa serial no está instalado. No es bool ni graphic/type; Es posible que un ID distinto de cero ya no exista en el mundo.

Comportamiento

  • Fuente del campo: _world.LastObject. El comando no selecciona, usa ni ataca el objeto.
  • Lee el estado local actual. No hay paquete, objetivo o actualización automática; las lecturas individuales pueden ver diferentes estados.

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

1. Llamada directa - guión directo

Parámetros y flujo de ejecución:

  • Lee el serial del último objeto utilizado.
var id = UO.LastObject();
UO.Print(Hex(id));

string Hex(object? value) => Convert.ToInt64(value).ToString("X");

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

Parámetros y flujo de ejecución:

  • Fuente del campo: _world.LastObject. El comando no selecciona, usa ni ataca el objeto.
return  RunScenario();
 object? RunScenario()
{
    var id = UO.LastObject();
    if (Truth(id != 0) && Truth(UO.Exists(id)))
    {
        UO.Print(UO.GetName(id));
    }

    return null;
}

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

3. Función auxiliar completa: clase de script

Parámetros y flujo de ejecución:

  • Lee el estado local actual. No hay paquete, objetivo o actualización automática; las lecturas individuales pueden ver diferentes estados.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var before = UO.LastObject();
        UO.Wait(500);
        var after = UO.LastObject();
        UO.Print(before = after);
        return null;
    }
}

Implementación del comando

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

UO.LastObject() — UO.LastObject()

Parámetros: Sin parámetros.

Resultado: dynamic / Any.

Durante la llamada:

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

case "lastobject": return new InjectionValue(bridge.GetLastObject());

UO.MakeFakeItem

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

Firmas de C#

void UO.MakeFakeItem(object? @type);
void UO.MakeFakeItem(object? @type, object? serial);
void UO.MakeFakeItem(object? @type, object? serial, object? count);
void UO.MakeFakeItem(object? @type, object? serial, object? count, object? color);
void UO.MakeFakeItem(object? @type, object? serial, object? count, object? color, object? x);
void UO.MakeFakeItem(object? @type, object? serial, object? count, object? color, object? x, object? y);

Crea o modifica solo un elemento de cliente local.

Parámetros

  • type - Obligatorio graphic 1..65535; sin nombre type a ResolveType: esta rama heredada usa Arg/int.
  • serial - Elemento serial opcional. 0 (predeterminado) asigna un ID libre del rango local alrededor de 0x7FFEFFFF; un elemento explícito serial puede coincidir con un elemento ya cargado y cambiar su modelo local.
  • count - Cantidad opcional, predeterminada 1. Lo no positivo se convierte en 1; máximo 65535.
  • color - Opcional hue, predeterminado 0; limitado a 0..65535.
  • x — Coordenadas mundiales opcionales, predeterminadas self; los negativos usan self, luego se limitan a 0...65535. Z es siempre el jugador actual.Z.
  • y — Coordenadas mundiales opcionales, predeterminadas self; los negativos usan self, luego se limitan a 0...65535. Z es siempre el jugador actual.Z.

Valor devuelto

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

Comportamiento

  • CreateFakeItem requiere jugador y graphic/artículo serial válido. GetOrCreateItem devuelve el modelo local; si está en un contenedor, elimina la conexión. Asigna ground contenedor 0xFFFFFFFF, graphic/amount/hue/X/Y/Z, Layer.Invalid, AllowedToDraw=true, IsDamageable=false y IsMulti=false.
  • El comando Legacy descarta el serial devuelto. Cuando 0 muestra un mensaje de error. El servidor no crea el artículo: la acción no proporciona un artículo real, botín ni derechos de transferencia. Por ejemplo, deje serial=0.

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.MakeFakeItem");
UO.MakeFakeItem(0x0E21);

1. Llamada directa - guión directo

Parámetros y flujo de ejecución:

  • Crea o modifica solo un elemento de cliente local.
UO.MakeFakeItem(0x0E21);

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

Parámetros y flujo de ejecución:

  • CreateFakeItem requiere jugador y graphic/artículo serial válido. GetOrCreateItem devuelve el modelo local; si está en un contenedor, elimina la conexión. Asigna ground contenedor 0xFFFFFFFF, graphic/amount/hue/X/Y/Z, Layer.Invalid, AllowedToDraw=true, IsDamageable=false y IsMulti=false.
return  RunScenario();
 object? RunScenario()
{
    UO.MakeFakeItem(0x0E21, 0, 5, 0);
    return null;
}

3. Función auxiliar completa: clase de script

Parámetros y flujo de ejecución:

  • El comando Legacy descarta el serial devuelto. Cuando 0 muestra un mensaje de error. El servidor no crea el artículo: la acción no proporciona un artículo real, botín ni derechos de transferencia. Por ejemplo, deje serial=0.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        UO.MakeFakeItem(0x0E21, 0, 1, 0, UO.GetX(), UO.GetY());
        return null;
    }
}

Implementación del comando

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

UO.MakeFakeItem(type) — UO.MakeFakeItem(Any)

Parámetros: type (Any)

Resultado: void / Unit.

Durante la llamada:

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

case "makefakeitem":

                {

                    int graphic = Arg(0);

                    int serial = Arg(1, 0);

                    int amount = Arg(2, 1);

                    int hue = Arg(3, 0);

                    int x = Arg(4, bridge.GetX(bridge.Self));

                    int y = Arg(5, bridge.GetY(bridge.Self));

                    int createdSerial = bridge.CreateFakeItem(graphic, serial, amount, hue, x, y);

                    if (createdSerial == 0)

                        SystemMessage("MakeFakeItem: invalid graphic/serial or no active player.");

                    break;

                }

UO.MakeFakeItem(type, serial) — UO.MakeFakeItem(Any,Any)

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

Resultado: void / Unit.

Durante la llamada:

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

case "makefakeitem":

                {

                    int graphic = Arg(0);

                    int serial = Arg(1, 0);

                    int amount = Arg(2, 1);

                    int hue = Arg(3, 0);

                    int x = Arg(4, bridge.GetX(bridge.Self));

                    int y = Arg(5, bridge.GetY(bridge.Self));

                    int createdSerial = bridge.CreateFakeItem(graphic, serial, amount, hue, x, y);

                    if (createdSerial == 0)

                        SystemMessage("MakeFakeItem: invalid graphic/serial or no active player.");

                    break;

                }

UO.MakeFakeItem(type, serial, count) — UO.MakeFakeItem(Any,Any,Any)

Parámetros: type (Any), serial (Any), count (Any)

Resultado: void / Unit.

Durante la llamada:

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

case "makefakeitem":

                {

                    int graphic = Arg(0);

                    int serial = Arg(1, 0);

                    int amount = Arg(2, 1);

                    int hue = Arg(3, 0);

                    int x = Arg(4, bridge.GetX(bridge.Self));

                    int y = Arg(5, bridge.GetY(bridge.Self));

                    int createdSerial = bridge.CreateFakeItem(graphic, serial, amount, hue, x, y);

                    if (createdSerial == 0)

                        SystemMessage("MakeFakeItem: invalid graphic/serial or no active player.");

                    break;

                }

UO.MakeFakeItem(type, serial, count, color) — UO.MakeFakeItem(Any,Any,Any,Any)

Parámetros: type (Any), serial (Any), count (Any), color (Any)

Resultado: void / Unit.

Durante la llamada:

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

case "makefakeitem":

                {

                    int graphic = Arg(0);

                    int serial = Arg(1, 0);

                    int amount = Arg(2, 1);

                    int hue = Arg(3, 0);

                    int x = Arg(4, bridge.GetX(bridge.Self));

                    int y = Arg(5, bridge.GetY(bridge.Self));

                    int createdSerial = bridge.CreateFakeItem(graphic, serial, amount, hue, x, y);

                    if (createdSerial == 0)

                        SystemMessage("MakeFakeItem: invalid graphic/serial or no active player.");

                    break;

                }

UO.MakeFakeItem(type, serial, count, color, x) — UO.MakeFakeItem(Any,Any,Any,Any,Any)

Parámetros: type (Any), serial (Any), count (Any), color (Any), x (Any)

Resultado: void / Unit.

Durante la llamada:

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

case "makefakeitem":

                {

                    int graphic = Arg(0);

                    int serial = Arg(1, 0);

                    int amount = Arg(2, 1);

                    int hue = Arg(3, 0);

                    int x = Arg(4, bridge.GetX(bridge.Self));

                    int y = Arg(5, bridge.GetY(bridge.Self));

                    int createdSerial = bridge.CreateFakeItem(graphic, serial, amount, hue, x, y);

                    if (createdSerial == 0)

                        SystemMessage("MakeFakeItem: invalid graphic/serial or no active player.");

                    break;

                }

UO.MakeFakeItem(type, serial, count, color, x, y) — UO.MakeFakeItem(Any,Any,Any,Any,Any,Any)

Parámetros: type (Any), serial (Any), count (Any), color (Any), x (Any), y (Any)

Resultado: void / Unit.

Durante la llamada:

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

case "makefakeitem":

                {

                    int graphic = Arg(0);

                    int serial = Arg(1, 0);

                    int amount = Arg(2, 1);

                    int hue = Arg(3, 0);

                    int x = Arg(4, bridge.GetX(bridge.Self));

                    int y = Arg(5, bridge.GetY(bridge.Self));

                    int createdSerial = bridge.CreateFakeItem(graphic, serial, amount, hue, x, y);

                    if (createdSerial == 0)

                        SystemMessage("MakeFakeItem: invalid graphic/serial or no active player.");

                    break;

                }

UO.MassMove

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

Firmas de C#

void UO.MassMove();
void UO.MassMove(object? delay);
void UO.MassMove(object? delay, object? quantity);
void UO.MassMove(object? delay, object? quantity, object? @type);
void UO.MassMove(object? delay, object? quantity, object? @type, object? destination);
void UO.MassMove(object? delay, object? quantity, object? @type, object? destination, object? x, object? y, object? z);

Permite una transferencia masiva única de artículos del tipo seleccionado. Después de Activar MassMove, arrastre un elemento adecuado con el mouse: a partir de él se determina el contenedor de origen. Otros elementos de este tipo de la misma fuente siguen automáticamente. El tercer parámetro es TYPE/Gráfico, no el ID del elemento. Todos los formularios incluyen espera de la primera transferencia manual; el destino explícito especifica adónde irá.

Parámetros

  • delay: el primer parámetro es el retraso entre solicitudes de transferencia en milisegundos, un número entero de 0 a 2147483647. 350 significa 0,35 segundos. Con 0 no se envía más de un siguiente acarreo por cuadro de juego. No se agrega ningún retraso a GrabDelay. Un valor negativo desactiva el modo y borra la cola; para apagar, se prefiere una notación UO.MassMove() clara.
  • quantity: el segundo parámetro es el límite TOTAL de artículos individuales (artículos), incluida la primera transferencia manual. Una pila/pila se considera un artículo, independientemente de la cantidad que contenga. 50 significa hasta 50 pilas enteras o 50 artículos individuales. La pila NO se divide en este límite. 0 o ningún parámetro: todos los elementos adecuados. No se permiten valores negativos.
  • type - El tercer parámetro es el código de tipo de artículo (Gráfico/Tipo), el número entero 0..65535, por ejemplo 0x0EED o la cadena "0x0EED" para oro. Esto NO es serial/ID y NO es el nombre AddObject. 0 o ausencia determina el tipo mediante la primera transferencia manual. Con un tipo explícito, arrastrar otro tipo no activa la cola; El modo continúa esperando un elemento adecuado.
  • destination: el cuarto parámetro es el propósito. La serie del cofre (número/cadena hexadecimal) o el nombre almacenado AddObject selecciona el contenedor; X/Y es un lugar dentro de su ventana. backpack, self y my seleccionan la mochila del personaje actual, también con coordenadas dentro de la mochila. ground o 0 selecciona tierra: X/Y/Z - posición absoluta en el mapa, los tres parámetros son obligatorios. lastcontainer — último contenedor abierto; lastobject, lasttarget, lastcorpse, finditem, laststatus son válidos si apuntan a un contenedor disponible. receiving y catchbag seleccionan el contenedor SetCatchBag instalado, y si no está instalado, la mochila. self/my aquí significa la mochila, aunque GetX(self) lee la posición del personaje. Los nombres se comparan sin distinguir entre mayúsculas y minúsculas; un nombre desconocido o aún no establecido genera un error en lugar de dejar caer el artículo al suelo. Sin destino, la ubicación se recuerda desde el primer reinicio manual: puedes poner la muestra dentro del contenedor o en el suelo. Para la Tierra, se recuerda el mundo X/Y/Z del primer reinicio.
  • x — Quinto parámetro. Para un contenedor, la coordenada dentro del contenedor; -1 o 65535 significa colocación automática. Para tierra, la coordenada absoluta del mapa, de 0 a 65535. Para un formulario sin X/Y/Z, -1 se usa en un contenedor explícito.
  • y — Sexto parámetro. Para un contenedor: la coordenada dentro del contenedor, -1/65535 para ubicación automática; para el terreno: la coordenada absoluta del mapa 0..65535. Para un formulario sin coordenadas en un contenedor explícito, utilice -1.
  • z: el séptimo parámetro es la altura de destino, número entero -128..127. El contenedor suele contener 0; en el suelo indican la altura real. En forma abreviada, la altura y X/Y se toman de la transferencia manual.

Valor devuelto

void: sin valor. Activar MassMove significa habilitar la espera de transferencia manual. La línea total informa la cantidad de artículos individuales para los cuales se enviaron solicitudes, incluido el primero. Una pila se considera un artículo; el resultado no confirma la aceptación de cada solicitud por parte del servidor.

Comportamiento

  • Se registran formularios con argumentos 0, 1, 2, 3, 4 y 7. X/Y/Z se especifican solo juntos. No se admiten formularios con argumentos 5, 6 o 8. Orden: retraso, cantidad, type, destino, x, y, z.
  • Active el modo ANTES de captura del mouse. La primera transferencia manual se considera un elemento: la pila de 1000 se transfiere por completo y consume solo un espacio del límite 50. El modo habilitado requiere pilas completas sin un diálogo dividido. Si se tomó parte de la pila antes de la inclusión, se rechaza la transferencia: se devuelve la parte y se comienza de nuevo.
  • Una activación se refiere a una transferencia manual. Después de seleccionar una muestra, el modo de selección se apaga; la cola restante se procesa automáticamente. Una llamada normal a MoveItem desde otro script no cuenta como selección de muestra manual.
  • Se compara el tipo de gráfico. El color no se filtra en este comando. Sólo se procesa el contenido directo del contenedor de origen; Las bolsas cerradas no se abren. Los elementos nuevos que aparecen después de crear la cola no se agregan a ella. Si la muestra estaba en el suelo, se tienen en cuenta los objetos cargados del mismo tipo dentro del radio de captura.
  • La cantidad es el límite superior de solicitudes. El comando no reintenta automáticamente las transferencias rechazadas por el servidor. Si el servidor falla, el destino no está disponible, el personaje muere o no se puede tomar el siguiente elemento, la operación finaliza. Cuando el cursor está ocupado, la cola espera hasta 5 segundos para quedar libre.
  • UO.MassMove() apaga el modo y cancela la cola restante. UO.TerminateAll() y dejando el personaje también lo cancela. Una solicitud que ya ha sido enviada no se revierte mediante cancelación. El cliente ejecuta la cola después de que regresa el comando; La siguiente línea del script no significa que el servidor ya haya completado la transferencia.
  • Para migrar completamente diferentes tipos de contenido, use EmptyContainer. Para llevar un artículo específico: MoveItem. Los ocho argumentos fuente, type, color, destino, x, y, z, retraso se refieren a MoveItems, no a MassMove.
  • Llamar repetidamente el mismo comando correctamente, mientras el modo todavía espera el primer arrastre del mouse, desactiva la espera: Desactivar MassMove/MassPriceMove aparece directamente en la ventana del juego. La siguiente llamada vuelve a activar el modo. Después de la primera transferencia, utilice el formulario sin argumentos para detener la cola restante. Las solicitudes que ya se han enviado no se revierten.

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.MassMove");
UO.MassMove(350, 0);

1. Habilite la transferencia del mouse sin limitar el número: secuencia de comandos directa

Parámetros y flujo de ejecución:

  • delay=350: Las siguientes solicitudes están separadas por al menos 350 ms. cantidad=0: No hay límite superior de usuarios.
  • type, destino y X/Y/Z no se transmiten. Después de Activar MassMove, arrastre la muestra desde la bolsa hasta el cofre: el tipo y la fuente se toman de allí, el destino es desde la ubicación de colocación.
  • Si la muestra es oro, se mueven las pilas de oro cargadas del mismo contenedor original. Quedan artículos de otros tipos. Print solo explica la acción manual posterior.
UO.MassMove(350, 0);
UO.Print("Drag one sample item to the destination container");

2. Transferir 50 pilas completas desde 100 - función de script

Parámetros y flujo de ejecución:

  • el retardo establece 350 ms. el total se pasa al segundo parámetro de cantidad y limita TODA la operación 50 a artículos individuales.
  • Si la fuente contiene pilas 100 del mismo tipo, se transferirán pilas 50 enteras: la primera manual una y otra 49. Cada pila puede contener una cantidad diferente; No afecta el contador. Si se trata de artículos individuales, se transfieren 50 artículos individuales.
  • No hay otras opciones: la primera captura y asignación se seleccionan con el mouse después de llamar.
return  RunScenario();
 object? RunScenario()
{
    var delay = 350;
    var total = 50;
    UO.MassMove(delay, total);
    return null;
}

3. Seleccione el tipo de oro y configure el cofre con anticipación - clase de escenario

Parámetros y flujo de ejecución:

  • goldType - TYPE oro, no ID una pila separada. AddObject guarda serial del cofre en el cofre; reemplace 0x40005678 con su ID.
  • retraso=350 ms, cantidad=50 artículos individuales, type=0x0EED, destino=cofre. El límite incluye la primera pila y no más de 49; todo el asunto.
  • x=-1 e y=-1 establecen la ubicación automática en el cofre, z=0. Estos son los siete parámetros.
  • La cola comenzará después de arrastrar manualmente el oro. Su bolso original se convertirá en la fuente. Un cofre explícito reemplaza la ubicación de reinicio del mouse; un elemento de otro tipo no inicia la cola.
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 goldType = "0x0EED";
        UO.AddObject("chest", "0x40005678");
        UO.MassMove(350, 50, goldType, "chest", -1, -1, 0);
        UO.Print("Now drag one gold stack from the source bag");
        return null;
    }
}

4. Seleccione una muestra con el mouse, pero establezca el terreno de antemano: guión directo

Parámetros y flujo de ejecución:

  • retardo=350 ms, cantidad=0 - todos los elementos adecuados. type=0 toma el tipo de la futura transferencia manual.
  • destino=0 significa tierra, por lo que se proporciona el triple completo x,y,z. GetX/GetY/GetZ aquí devuelve la posición actual del personaje.
  • Después de llamar, levante y suelte la muestra con el mouse. El comando lo enviará junto con otros elementos coincidentes a las coordenadas especificadas, incluso si el mouse estaba sobre el contenedor. El servidor comprueba la disponibilidad de terreno.
var x = UO.GetX();
var y = UO.GetY();
var z = UO.GetZ();
UO.MassMove(350, 0, 0, 0, x, y, z);

5. Mover hasta diez artículos de un tipo conocido a una mochila - función de script

Parámetros y flujo de ejecución:

  • retraso=500 — medio segundo; cantidad=10 - diez artículos/pilas individuales para toda la operación.
  • type=0x0F7A — tipo gráfico del elemento. Por favor indique su tipo; El número de serie del formulario 0x40001234 no está permitido aquí.
  • destino=backpack - mochila del personaje. Las coordenadas no se transmiten, por lo que x=-1, y=-1, z=0 se utilizan en su interior.
  • La fuente se selecciona transfiriendo primero manualmente un elemento adecuado. Si la fuente ya es una mochila, elija una bolsa de fuente diferente para llevarla útil.
return  RunScenario();
 object? RunScenario()
{
    UO.MassMove(500, 10, "0x0F7A", "backpack");
    UO.Print("Drag one matching item from the source chest");
    return null;
}

6. Seleccione un lugar dentro de un cofre basándose en un objeto que ya se encuentra - clase de escenario

Parámetros y flujo de ejecución:

  • Primero, coloque manualmente el artículo en la ubicación deseada en el cofre. El primer AddObject selecciona el cofre y lo almacena ID en el cofre. El segundo selecciona el elemento que contiene y almacena ID en position_sample.
  • GetX/GetY para un elemento dentro de un contenedor devuelve sus coordenadas dentro de ese contenedor. No dependen de dónde esté ubicada la ventana del cofre en la pantalla.
  • retraso=350 ms, cantidad=50 elementos enteros, type=0 determinado por futura transferencia manual desde la fuente, destino=cofre.
  • xey definen la ubicación seleccionada dentro del cofre, el último z=0. El objeto position_sample sólo sirve para leer coordenadas; el origen y el tipo que se migran están determinados por la migración manual posterior.
  • Para una mochila, reemplace el cofre con backpack o self. Para tierra, use ground y coordenadas del mapa como UO.GetX(), UO.GetY(), UO.GetZ() sin argumentos para la posición actual del personaje.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        UO.Print("Select the destination chest");
        UO.AddObject("chest");
        UO.Print("Select an item already at the desired position inside that chest");
        UO.AddObject("position_sample");
        var x = UO.GetX("position_sample");
        var y = UO.GetY("position_sample");
        UO.MassMove(350, 50, 0, "chest", x, y, 0);
        UO.Print("Drag one source item to start the transfer");
        return null;
    }
}

7. Del cofre al suelo: selecciona un lugar con el mouse - guión directo

Parámetros y flujo de ejecución:

  • delay=350: al menos 350 ms entre solicitudes posteriores. cantidad=50 - hasta 50 artículos individuales/pilas completas, incluida una muestra; estas no son unidades 50 de la misma pila.
  • Después de Activar MassMove, recoge el objeto en el cofre abierto y colócalo en el suelo con el mouse. Su tipo y cofre original están determinados por el patrón; Los destinos mundiales X/Y/Z se recuerdan en la ubicación de este reinicio.
  • Los elementos restantes del mismo tipo cargados en este cofre se envían al mismo punto en el suelo. El contenido de las bolsas encajables y de otros tipos no se ve afectado. Para todos los elementos coincidentes, reemplace 50 con 0.
  • MassMove no tiene valor de retorno. El procedimiento finaliza después de habilitar el modo, la cola continúa funcionando en el cliente. El mensaje final cuenta las solicitudes enviadas, no las confirmaciones del servidor. Para cancelar la cola restante, llame a UO.MassMove().
UO.MassMove(350, 50);
UO.Print("Drag one item from the chest onto the ground");

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

Parámetros: Sin parámetros.

Resultado: void / Unit.

Durante la llamada:

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

case "massmove":

                    if (arguments.Length == 0) bridge.MassMove(-1, 0, 0, -1, -1, -1, 0);

                    else bridge.MassMove(NumberConversions.ToInt(arguments[0]),

                        arguments.Length > 1 ? NumberConversions.ToInt(arguments[1]) : 0,

                        arguments.Length > 2 ? ResolveType(arguments[2]) : 0,

                        arguments.Length > 3 ? ResolveTransferDestination(arguments[3], true) : -1,

                        arguments.Length > 4 ? NumberConversions.ToInt(arguments[4]) : -1,

                        arguments.Length > 5 ? NumberConversions.ToInt(arguments[5]) : -1,

                        arguments.Length > 6 ? NumberConversions.ToInt(arguments[6]) : 0);

                    break;

UO.MassMove(delay) — UO.MassMove(Any)

Parámetros: delay (Any)

Resultado: void / Unit.

Durante la llamada:

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

case "massmove":

                    if (arguments.Length == 0) bridge.MassMove(-1, 0, 0, -1, -1, -1, 0);

                    else bridge.MassMove(NumberConversions.ToInt(arguments[0]),

                        arguments.Length > 1 ? NumberConversions.ToInt(arguments[1]) : 0,

                        arguments.Length > 2 ? ResolveType(arguments[2]) : 0,

                        arguments.Length > 3 ? ResolveTransferDestination(arguments[3], true) : -1,

                        arguments.Length > 4 ? NumberConversions.ToInt(arguments[4]) : -1,

                        arguments.Length > 5 ? NumberConversions.ToInt(arguments[5]) : -1,

                        arguments.Length > 6 ? NumberConversions.ToInt(arguments[6]) : 0);

                    break;

UO.MassMove(delay, quantity) — UO.MassMove(Any,Any)

Parámetros: delay (Any), quantity (Any)

Resultado: void / Unit.

Durante la llamada:

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

case "massmove":

                    if (arguments.Length == 0) bridge.MassMove(-1, 0, 0, -1, -1, -1, 0);

                    else bridge.MassMove(NumberConversions.ToInt(arguments[0]),

                        arguments.Length > 1 ? NumberConversions.ToInt(arguments[1]) : 0,

                        arguments.Length > 2 ? ResolveType(arguments[2]) : 0,

                        arguments.Length > 3 ? ResolveTransferDestination(arguments[3], true) : -1,

                        arguments.Length > 4 ? NumberConversions.ToInt(arguments[4]) : -1,

                        arguments.Length > 5 ? NumberConversions.ToInt(arguments[5]) : -1,

                        arguments.Length > 6 ? NumberConversions.ToInt(arguments[6]) : 0);

                    break;

UO.MassMove(delay, quantity, type) — UO.MassMove(Any,Any,Any)

Parámetros: delay (Any), quantity (Any), type (Any)

Resultado: void / Unit.

Durante la llamada:

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

case "massmove":

                    if (arguments.Length == 0) bridge.MassMove(-1, 0, 0, -1, -1, -1, 0);

                    else bridge.MassMove(NumberConversions.ToInt(arguments[0]),

                        arguments.Length > 1 ? NumberConversions.ToInt(arguments[1]) : 0,

                        arguments.Length > 2 ? ResolveType(arguments[2]) : 0,

                        arguments.Length > 3 ? ResolveTransferDestination(arguments[3], true) : -1,

                        arguments.Length > 4 ? NumberConversions.ToInt(arguments[4]) : -1,

                        arguments.Length > 5 ? NumberConversions.ToInt(arguments[5]) : -1,

                        arguments.Length > 6 ? NumberConversions.ToInt(arguments[6]) : 0);

                    break;

UO.MassMove(delay, quantity, type, destination) — UO.MassMove(Any,Any,Any,Any)

Parámetros: delay (Any), quantity (Any), type (Any), destination (Any)

Resultado: void / Unit.

Durante la llamada:

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

case "massmove":

                    if (arguments.Length == 0) bridge.MassMove(-1, 0, 0, -1, -1, -1, 0);

                    else bridge.MassMove(NumberConversions.ToInt(arguments[0]),

                        arguments.Length > 1 ? NumberConversions.ToInt(arguments[1]) : 0,

                        arguments.Length > 2 ? ResolveType(arguments[2]) : 0,

                        arguments.Length > 3 ? ResolveTransferDestination(arguments[3], true) : -1,

                        arguments.Length > 4 ? NumberConversions.ToInt(arguments[4]) : -1,

                        arguments.Length > 5 ? NumberConversions.ToInt(arguments[5]) : -1,

                        arguments.Length > 6 ? NumberConversions.ToInt(arguments[6]) : 0);

                    break;

UO.MassMove(delay, quantity, type, destination, x, y, z) — UO.MassMove(Any,Any,Any,Any,Any,Any,Any)

Parámetros: delay (Any), quantity (Any), type (Any), destination (Any), x (Any), y (Any), z (Any)

Resultado: void / Unit.

Durante la llamada:

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

case "massmove":

                    if (arguments.Length == 0) bridge.MassMove(-1, 0, 0, -1, -1, -1, 0);

                    else bridge.MassMove(NumberConversions.ToInt(arguments[0]),

                        arguments.Length > 1 ? NumberConversions.ToInt(arguments[1]) : 0,

                        arguments.Length > 2 ? ResolveType(arguments[2]) : 0,

                        arguments.Length > 3 ? ResolveTransferDestination(arguments[3], true) : -1,

                        arguments.Length > 4 ? NumberConversions.ToInt(arguments[4]) : -1,

                        arguments.Length > 5 ? NumberConversions.ToInt(arguments[5]) : -1,

                        arguments.Length > 6 ? NumberConversions.ToInt(arguments[6]) : 0);

                    break;

ClassicUO — Bad Newbie & C# Scripts IDE

ClassicUO — Bad Newbie & C# Scripts IDE

Clone this wiki locally