Skip to content

ES UO Topic world geometry

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

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

Mundo y geometría

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

Coordenadas, distancias, línea de visión, capacidad para cruzar el país y datos de mapas. Obtener una ruta se describe por separado en Movimiento.

Secciones

Tema Comandos y explicaciones
X / Y / Z UO.GetX · UO.GetY · UO.GetZ
Distance UO.GetDistance · UO.Dist
LOS UO.CheckLOS · UO.LOSOptions
World Number UO.WorldNum
World Cells UO.GetWorldCell · UO.GetWorldTilesArray
Passability UO.IsWorldCellPassable · UO.GetNextStepZ
Surface Z UO.GetSurfaceZ
Map Cells UO.GetMapCell
Land Tiles UO.GetLandTileAt · UO.GetLandTileData · UO.GetLandTilesArray · UO.GetLandTilesArrayEx
Static Tiles UO.GetStaticTileAt · UO.GetStaticTileData · UO.GetStaticTiles · UO.GetStaticTilesArray · UO.GetStaticTilesArrayEx
Tile Flags UO.GetTileFlags · UO.ConvertIntegerToFlags
Tile Height UO.GetTileHeight
Tile Layer UO.GetTileLayer
Tile Name UO.GetTileName
Water Tiles UO.IsWaterTile
Tree Tiles UO.IsTreeTile
Mine Tiles UO.IsMineTile

Todos los comandos del tema

X / Y / Z

UO.X · UO.Y · UO.Z · UO.GetX · UO.GetY · UO.GetZ

Distancia

UO.Dist · UO.GetDistance

LOS

UO.CheckLOS · UO.LOSOptions

Número mundial

UO.WorldNum · UO.GetWorldNum

Células mundiales / Pasabilidad

UO.GetWorldCell · UO.GetMapCell · UO.IsWorldCellPassable · UO.GetSurfaceZ · UO.GetNextStepZ · UO.GetWorldTilesArray

Azulejos de tierra

UO.GetLandscapeTile · UO.GetLandTileAt · UO.GetLandTileData · UO.GetLandTilesArray · UO.GetLandTilesArrayEx

Azulejos estáticos

UO.GetStaticArt · UO.GetStaticTileAt · UO.GetStaticTileData · UO.GetStaticTiles · UO.GetStaticTilesArray · UO.GetStaticTilesArrayEx · UO.ReadStaticsXY · UO.PrivateGetTile · UO.GetTileXYM · UO.GetLayerCount

Propiedades del mosaico

UO.GetTileFlags · UO.GetTileHeight · UO.GetTileLayer · UO.GetTileName · UO.IsWaterTile · UO.IsTreeTile · UO.IsMineTile · UO.ConvertIntegerToFlags

Estática del cliente

UO.AddUserStatic · UO.ClearUserStatics · UO.GetUserStatic · UO.GetUserStatics · UO.RemoveUserStatic · UO.UserStaticExists

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

Parámetros, resultado y todos los escenarios

var target = UO.GetSerial("lasttarget");
if (Truth(UO.Exists(target)))
{
    var distance = UO.GetDistance(target);
    if (Truth(distance <= 2))
    {
        UO.Print("Target is within two tiles");
    }
}

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

UO.IsWorldCellPassable

Parámetros, resultado y todos los escenarios

var x = UO.GetX();
var y = UO.GetY();
var z = UO.GetZ();
var result = UO.IsWorldCellPassable(x,y,z,x+1,y,z,UO.WorldNum());
if (Truth(Truth(result[0]) == true))
{
    UO.Print("Passable, Z=" + Convert.ToString(result[1]));
}
else
{
    UO.Print("Blocked");
}

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

Partes de la referencia

1 · 2

Referencia completa de comandos

UO.AddUserStatic

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

Firmas de C#

dynamic UO.AddUserStatic(object? staticItem, object? worldNum);
int UO.AddUserStatic(object? graphic, object? x, object? y, object? z, object? hue, object? map);

Agrega una entrada estática personalizada al estado del script local. El graphic numérico se utiliza para la verificación de obstáculos locales mediante el buscador de ruta; el objeto no se crea en el servidor. Una llamada de dos argumentos con texto sin numerar conserva los valores heredados y no agrega estática al buscador de ruta.

Parámetros

  • staticItem: valor numérico graphic o de texto heredado.
  • worldNum - índice de la tarjeta para grabación o estática local.
  • graphic — ID estático de 0 a 65535.
  • z — altura. Cuando se agrega al buscador de rutas, el valor se limita al rango firmado byte.
  • hue - hue; cuando se agrega, se limita al rango de 0 a 65535.
  • map — índice del mapa; para el procesamiento del administrador, el rango está limitado a 0–255.
  • x — Estática personalizada del Mundo X; int. El administrador acepta coordenadas dentro del mapa cargado actualmente.
  • y — Estática personalizada del Mundo Y; int. El administrador acepta coordenadas dentro del mapa cargado actualmente.

Valor devuelto

Positivo ID de la entrada creada. Para la forma de seis parámetros, graphic, x, y o map negativos, así como graphic encima de 65535 dan como resultado -1. ID se puede pasar a UO.UserStaticExists, UO.RemoveUserStatic o usarse para verificar/eliminar un registro heredado. El ID devuelto por sí solo no confirma que la estática será visible o aplicada en el servidor.

Comportamiento

    • UO.AddUserStatic('tree', 0): dado que tree no es un número, guarda un par de valores originales como un registro heredado en el estado de ejecución; Pathfinder no lo usa.
  • Una llamada de dos parámetros con el numérico graphic agrega la estática de ese graphic a las coordenadas actuales del personaje, con los z y hue 0 del personaje.
  • La llamada de seis parámetros agrega una estática con el graphic, las coordenadas, la altitud, el hue y el mapa dados. Pathfinding solo lo tiene en cuenta en el mapa activo y de acuerdo con las banderas graphic en los datos del mosaico del cliente.

Estas entradas son locales para el cliente de script: no crean un objeto de juego, no realizan una solicitud de red ni modifican datos de fragmentos.

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

1. Guarde el par como datos heredados; El texto StaticItem no crea un obstáculo para el buscador de caminos. - guión directo

Parámetros y flujo de ejecución:

  • Guarde el par como datos heredados; El texto StaticItem no crea un obstáculo para el buscador de caminos.
var legacyId = UO.AddUserStatic("tree", 0);
UO.Print(Convert.ToString(legacyId));

2. El número graphic se agrega a la posición del personaje en el mapa actual. - función de guión

Parámetros y flujo de ejecución:

  • El número graphic se agrega a la posición del personaje en el mapa actual.
return  RunScenario();
 object? RunScenario()
{
    var staticId = UO.AddUserStatic(0x0CCA, UO.GetWorldNum());
    UO.Print(Convert.ToString(staticId));
    return null;
}

3. Agregue explícitamente graphic estático local a la posición especificada y al mapa especificado. - clase de guión

Parámetros y flujo de ejecución:

  • Agregue explícitamente graphic estático local a la posición especificada y al mapa especificado.
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 staticId = UO.AddUserStatic(0x0CCA, UO.GetX(), UO.GetY(), UO.GetZ(), 0, UO.GetWorldNum());
        UO.Print(Convert.ToString(staticId));
        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.AddUserStatic(staticItem, worldNum) — UO.AddUserStatic(Any,Any)

Parámetros: staticItem (Any), worldNum (Any)

Resultado: dynamic / Any.

Durante la llamada:

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

case "adduserstatic":

                {

                    int map = Arg(1, bridge.WorldNumber);

                    if (arguments[0].Kind != InjectionValueKind.Array)

                    {

                        int graphic = 0;

                        if (arguments[0].Kind == InjectionValueKind.String &&

                            !NumberConversions.TryStr2Int(arguments[0].String, out graphic))

                        {

                            int legacyId = state.NextUserStaticId++;

                            state.UserStatics[legacyId] = Text(0) + "|" + Text(1);

                            return new InjectionValue(legacyId);

                        }

                        graphic = arguments[0].Kind == InjectionValueKind.String

                            ? graphic

                            : NumberConversions.ToInt(arguments[0]);

                        return new InjectionValue(AddUserStatic(graphic, bridge.GetX(bridge.Self), bridge.GetY(bridge.Self),

                            bridge.GetZ(bridge.Self), 0, map));

                    }

                    if (arguments[0].Array.Length < 4)

                        throw new NativeSubrutineException("AddUserStatic expects [graphic,x,y,z,color] and world number, or graphic,x,y,z,color,world.");

                    InjectionValue[] item = arguments[0].Array;

                    return new InjectionValue(AddUserStatic(

                        NumberConversions.ToInt(item[0]), NumberConversions.ToInt(item[1]), NumberConversions.ToInt(item[2]),

                        NumberConversions.ToInt(item[3]), item.Length > 4 ? NumberConversions.ToInt(item[4]) : 0, map));

                }

UO.AddUserStatic(graphic, x, y, z, hue, map) — UO.AddUserStatic(Any,Any,Any,Any,Any,Any)

Parámetros: graphic (Any), x (Any), y (Any), z (Any), hue (Any), map (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(AddUserStatic(

                    NumberConversions.ToInt(values[0]), NumberConversions.ToInt(values[1]), NumberConversions.ToInt(values[2]),

                    NumberConversions.ToInt(values[3]), NumberConversions.ToInt(values[4]), NumberConversions.ToInt(values[5])))

UO.CheckLOS

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

Firmas de C#

dynamic UO.CheckLOS(object? xfrom, object? yfrom, object? zfrom, object? xto, object? yto, object? zto, object? worldNum);

Comprueba la transitabilidad local de una línea entre dos puntos del mapa mediante CheckPortableLineOfSight.

Parámetros

  • xfrom — Fuente X: 0...65535.
  • yfrom — Fuente Y: 0...65535.
  • zfrom — Z inicial, int.
  • xto - Final X: 0..65535.
  • yto - Final Y: 0..65535.
  • zto — Z final, int.
  • worldNum - 0..255. Un haz de longitud distinta de cero lee solo el _world.Map/World.Map actualmente cargado: a través de CheckWorldStep necesitas WorldNum == _world.MapIndex y un Player.Pathfinder en vivo. Otra faceta no se carga ni se solicita; no hay mapa/personaje/buscatrazos o el paso no está disponible - 0. Excluir X/Y idéntico omite todo el ciclo de celdas: con X/Y en 0..65535, WorldNum en 0..255 y abs(Zfrom-Zto)<=20 devuelve 1 incluso sin una tarjeta cargada o con un número de tarjeta diferente. Esta no es una prueba de geometría o accesibilidad. El resultado es una solución de servidor local, no LOS.

Valor devuelto

int 1 — el rayo local ha alcanzado X/Y y la altura final difiere de Zto en no más de 20; 0: coordenadas, obstáculo o límite de verificación no válidos.

Comportamiento

  • El haz viaja mediante el algoritmo de Bresenham, con un máximo de pasos 4096. En cada celda, se tienen en cuenta BadLocations, CheckWorldStep y la altura devuelta.
  • Cuando LosOptions != 0 adicionalmente se usa CheckLosCell; El bit 0x100 comprueba ambos cuadrados laterales de la diagonal. La verificación de geometría local no valida las reglas LOS específicas del servidor y no mueve nada.
  • Menor byte (valor & 0xFF) selecciona el algoritmo 1..4; otros valores del menor byte en CheckLosCell usan el algoritmo 3. Los algoritmos 1/2 bloquean Muro e Intransitable, 3 además NoShoot y 4 habilita NoShoot solo con 0x200 y permite obstáculos de ventana solo con 0x400. El bit 0x100 además verifica ambas celdas laterales de cada paso de haz diagonal para cualquier algoritmo seleccionado. value=0 desactiva las comprobaciones adicionales CheckLosCell/diagonal, pero BadLocations y CheckWorldStep permanecen. Por ejemplo, 4+0x100+0x200+0x400 selecciona personalizado con tres indicadores; setter conserva el algoritmo int original, no normalizado.
  • Un haz de longitud distinta de cero lee solo el _world.Map/World.Map actualmente cargado: a través de CheckWorldStep necesitas WorldNum == _world.MapIndex y un Player.Pathfinder en vivo. Otra faceta no se carga ni se solicita; no hay mapa/personaje/buscatrazos o el paso no está disponible - 0. Excluir X/Y idéntico omite todo el ciclo de celdas: con X/Y en 0..65535, WorldNum en 0..255 y abs(Zfrom-Zto)<=20 devuelve 1 incluso sin una tarjeta cargada o con un número de tarjeta diferente. Esta no es una prueba de geometría o accesibilidad. El resultado es una solución de servidor local, no LOS.
  • CheckLosCell omite el Land/Static/Multi/Item cargado de una celda. Bloques de tierra intransitables con abs(rayZ-land.Z)<=20. Los indicadores Estático/Multi/Elemento solo son válidos en el rango mosaico.Z-2 .. mosaico.Z+max(1,Height)+2; La ventana personalizada permitida se omite hasta que se marca Muro/Intransitable/NoShoot. El haz X/Y utiliza Bresenham, pasos máximos de 4096; Z se toma de las superficies CheckWorldStep, no se interpola a Zto, la tolerancia de altura final es 20.

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.CheckLOS(UO.X(), UO.Y(), UO.Z(), UO.X() + 1, UO.Y(), UO.Z(), UO.WorldNum());
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

1. Línea en la celda actual - guión directo

Parámetros y flujo de ejecución:

  • Puntos idénticos pasan dentro de X/Y/mapa aceptable.
var x = UO.GetX();
var y = UO.GetY();
var z = UO.GetZ();
var visible = UO.CheckLOS(x,y,z,x,y,z,UO.WorldNum());
UO.Print(Convert.ToString(visible));

2. Comprobando celda adyacente - función de script

Parámetros y flujo de ejecución:

  • La altura y la permeabilidad de la celda vecina se leen en el mapa local.
return  RunScenario();
 object? RunScenario()
{
    var x = UO.GetX();
    var y = UO.GetY();
    var z = UO.GetZ();
    var clear = UO.CheckLOS(x, y, z, x + 1, y, z, UO.WorldNum());
    UO.Print(Convert.ToString(clear));
    return null;
}

3. Coordenada no válida: clase de script

Parámetros y flujo de ejecución:

  • Se rechaza una X negativa con un resultado de 0 sin pasar por el mapa.
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 clear = UO.CheckLOS(-1, 0, 0, 0, 0, 0, 0);
        UO.Print(Convert.ToString(clear));
        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.CheckLOS(xfrom, yfrom, zfrom, xto, yto, zto, worldNum) — UO.CheckLOS(Any,Any,Any,Any,Any,Any,Any)

Parámetros: xfrom (Any), yfrom (Any), zfrom (Any), xto (Any), yto (Any), zto (Any), worldNum (Any)

Resultado: dynamic / Any.

Durante la llamada:

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

case "checklos": return new InjectionValue(CheckPortableLineOfSight(Arg(0), Arg(1), Arg(2), Arg(3), Arg(4), Arg(5), Arg(6)) ? 1 : 0);

UO.ClearUserStatics

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

Firmas de C#

void UO.ClearUserStatics();

Elimina todas las entradas de tiempo de ejecución estáticas del usuario y los objetos del administrador estático local.

Parámetros

No hay parámetros.

Valor devuelto

void: sin valor de retorno.

Comportamiento

  • Los objetos State.UserStatics y Manager se borran. Los archivos de mapas cargados y los elementos reales del servidor 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.ClearUserStatics");
UO.ClearUserStatics();

1. Estado claro: guión directo

Parámetros y flujo de ejecución:

  • Elimina todas las entradas de tiempo de ejecución estáticas del usuario y los objetos del administrador estático local.
UO.ClearUserStatics();

2. Borrar después de la configuración: función de script

Parámetros y flujo de ejecución:

  • Agregue una estática local en la celda actual y luego elimine todas las estáticas personalizadas.
return  RunScenario();
 object? RunScenario()
{
    var localStatic = UO.AddUserStatic(0x0CCA, UO.GetX(), UO.GetY(), UO.GetZ(), 0, UO.WorldNum());
    UO.ClearUserStatics();
    return null;
}

3. Volver a purgar: clase de secuencia de comandos

Parámetros y flujo de ejecución:

  • Borrar un conjunto vacío es aceptable y no crea una nueva configuració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()
    {
        UO.ClearUserStatics();
        UO.ClearUserStatics();
        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.ClearUserStatics() — UO.ClearUserStatics()

Parámetros: Sin parámetros.

Resultado: void / Unit.

Durante la llamada:

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

case "clearuserstatics": state.UserStatics.Clear(); bridge.ClearUserStatics(); return InjectionValue.Unit;

UO.ConvertIntegerToFlags

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

Firmas de C#

dynamic UO.ConvertIntegerToFlags(object? group, object? value);

Analiza una máscara numérica de indicadores de mosaicos en una matriz de nombres de enumeración TileFlag.

Parámetros

  • group - int: solo 1 o 2 habilitan la conversión; cualquier otro valor da como resultado una matriz vacía.
  • value: una máscara que Arg convierte en un int de bit 32 con signo, luego el puente conduce a ulong. Para indicadores de bits 64 altos, este formulario no conserva la máscara completa.

Valor devuelto

Matriz de cadenas denominadas distintas de cero TileFlag cuyos bits están completamente presentes en la máscara. La máscara 0 produce una matriz vacía.

Comportamiento

  • Los grupos 1 y 2 usan el mismo Enum.GetValues en lugar de directorios diferentes. Esta es una transformación de máscara local; Tiledata no se solicita.
  • El registro API usa object?, pero el despachador Arg(1) envía int. El signo negativo int se extiende cuando se transmite a ulong. GetTileFlags también devuelve solo los bits 32 bajos con la firma int: este par compatible no proporciona el contrato completo de datos de mosaico de 64 bits.

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

1. Máscara nula - guión directo

Parámetros y flujo de ejecución:

  • No hay ningún indicador distinto de cero en la máscara 0.
var flags = UO.ConvertIntegerToFlags(1,0);
UO.Print(Convert.ToString(ArrayLength(flags)));

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;

2. Máscara de bits bajos: función de secuencia de comandos

Parámetros y flujo de ejecución:

  • La matriz contiene los nombres reales TileFlag de la máscara seleccionada.
return  RunScenario();
 object? RunScenario()
{
    var flags = UO.ConvertIntegerToFlags(2, 1);
    for (int i = (int)(0); i <= ArrayLength(flags) - 1; i += (int)(1))
    {
        UO.Print(flags[i]);
    }

    return null;
}

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;

3. Grupo no válido: clase de secuencia de comandos

Parámetros y flujo de ejecución:

  • Este comando no acepta el grupo 0 y devuelve una matriz vacía.
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.ConvertIntegerToFlags(0, 1);
        UO.Print(Convert.ToString(ArrayLength(flags)));
        return null;
    }

    int ArrayLength(object? value) => value is System.Array array ? array.Length : 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.ConvertIntegerToFlags(group, value) — UO.ConvertIntegerToFlags(Any,Any)

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

Resultado: dynamic / Any.

Durante la llamada:

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

case "convertintegertoflags":

                    return new InjectionValue(bridge.ConvertTileFlags(Arg(0), Arg(1))

                        .Select(flag => new InjectionValue(flag)).ToArray());

UO.Dist

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

Firmas de C#

int UO.Dist(object? xfrom, object? yfrom, object? xto, object? yto);

Calcula la distancia en celdas entre dos puntos del mundo: la mayor de las diferencias absolutas entre X e Y.

Parámetros

  • xfrom — Coordenada X del punto de partida.
  • yfrom — Coordenada Y del punto de partida.
  • xto: la coordenada de asignación X.
  • yto: la coordenada de asignación Y.

Valor devuelto

int — distancia en celdas, no negativa para coordenadas válidas. 0 significa lo mismo XY, 1 - una celda. Esta es una cantidad, no una señal de éxito. Una distancia de comparación separada <= 2 devuelve bool true o false; la distancia en sí sigue siendo int.

Comportamiento

  • Calcule solo coordenadas: sin lotes, sin esperas, sin carga de mapas, sin verificación de obstáculos, sin Z, sin mapa mundial. El equipo no busca una ruta transitable y no garantiza la consecución del objetivo. Los puntos deben pertenecer al mismo sistema de coordenadas; Evitar obstáculos puede alargar el camino.
  • Se necesitan los cuatro parámetros. Envíe las coordenadas mundiales int en el rango documentado 0...65535. object? en la firma indica un adaptador universal, no el ID del artículo. Estos comandos no tienen valores predeterminados, coordenadas dentro del cofre, quinto Z y sobrecarga con un objeto.
  • Fórmula: Max(Abs(Xto-Xfrom), Abs(Yto-Yfrom)). Cuando reorganizas los puntos, el resultado es el mismo. Esta no es la distancia euclidiana, ni la suma de las diferencias, ni el número de pasos al sortear un obstáculo.

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.Dist(100, 100, 103, 104);
UO.Print("Dist: " + Convert.ToString(result));

1. Cálculo directo - guión directo

Parámetros y flujo de ejecución:

  • De (100,100) a (103,104): las diferencias absolutas son 3 y 4, con un máximo de 4. Principal regresa int 4.
  • int — distancia en celdas, no negativa para coordenadas válidas. 0 significa lo mismo XY, 1 - una celda. Esta es una cantidad, no una señal de éxito. Una distancia de comparación separada <= 2 devuelve bool true o false; la distancia en sí sigue siendo int.
  • Fórmula: Max(Abs(Xto-Xfrom), Abs(Yto-Yfrom)). Cuando reorganizas los puntos, el resultado es el mismo. Esta no es la distancia euclidiana, ni la suma de las diferencias, ni el número de pasos al sortear un obstáculo.
return UO.Dist(100,100,103,104);

2. Comprobar correctamente el resultado es función del script

Parámetros y flujo de ejecución:

  • De (100,100) a (101,99) la distancia es 1. Una comparación separada de la distancia<=2 da true=1. Main devuelve "1:1": la primera unidad es la distancia, la segunda es el resultado lógico de la comparación.
  • int — distancia en celdas, no negativa para coordenadas válidas. 0 significa lo mismo XY, 1 - una celda. Esta es una cantidad, no una señal de éxito. Una distancia de comparación separada <= 2 devuelve bool true o false; la distancia en sí sigue siendo int.
  • Fórmula: Max(Abs(Xto-Xfrom), Abs(Yto-Yfrom)). Cuando reorganizas los puntos, el resultado es el mismo. Esta no es la distancia euclidiana, ni la suma de las diferencias, ni el número de pasos al sortear un obstáculo.
return  RunScenario();
 object? RunScenario()
{
    var distance = UO.Dist(100, 100, 101, 99);
    var close = distance <= 2;
    return Convert.ToString(distance) + ":" + Convert.ToString(close);
    return null;
}

3. Análisis completo del script: clase de script

Parámetros y flujo de ejecución:

  • UO.Dist devuelve 4. RebuildTileDistance calcula las diferencias mediante Abs, las compara y devuelve la mayor, al igual que 4. Principal devuelve "4:4". El asistente se muestra completamente en el ejemplo y no es un comando más del motor.
  • int — distancia en celdas, no negativa para coordenadas válidas. 0 significa lo mismo XY, 1 - una celda. Esta es una cantidad, no una señal de éxito. Una distancia de comparación separada <= 2 devuelve bool true o false; la distancia en sí sigue siendo int.
  • Fórmula: Max(Abs(Xto-Xfrom), Abs(Yto-Yfrom)). Cuando reorganizas los puntos, el resultado es el mismo. Esta no es la distancia euclidiana, ni la suma de las diferencias, ni el número de pasos al sortear un obstáculo.
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 actual = UO.Dist(100, 100, 103, 104);
        var rebuilt = RebuildTileDistance(100, 100, 103, 104);
        return Convert.ToString(actual) + ":" + Convert.ToString(rebuilt);
        return null;
    }

    dynamic RebuildTileDistance(dynamic Xfrom, dynamic Yfrom, dynamic Xto, dynamic Yto)
    {
        var dx = Math.Abs(Xto - Xfrom);
        var dy = Math.Abs(Yto - Yfrom);
        if (Truth(dx > dy))
        {
            return dx;
        }

        return dy;
    }

    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.Dist(xfrom, yfrom, xto, yto) — UO.Dist(Any,Any,Any,Any)

Parámetros: xfrom (Any), yfrom (Any), xto (Any), yto (Any)

Resultado: int / Integer.

Durante la llamada:

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

case "dist": return new InjectionValue(arguments.Length >= 4

                    ? GetDistance(Arg(0), Arg(1), Arg(2), Arg(3))

                    : bridge.GetDistance(Arg(0)));

UO.GetDistance

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

Firmas de C#

int UO.GetDistance(object? id);
int UO.GetDistance(object? x, object? y);
int UO.GetDistance(object? id1, object? x2, object? y2);
int UO.GetDistance(object? x1, object? y1, object? x2, object? y2);

Mide la distancia en celdas en función de las diferencias máximas X/Y. Esta es una estimación geométrica sin búsqueda de caminos.

Parámetros

  • id — Un argumento: serial o el alias del objeto cargado, la distancia a la que desea llegar.
  • x — Dos argumentos: destino mundial. El comienzo es GetX(self), GetY(self).
  • y — Dos argumentos: destino mundial. El comienzo es GetX(self), GetY(self).
  • id1 — En forma de tres argumentos, el serial/alias del objeto cuyas coordenadas sirven como origen.
  • x1 — En forma de cuatro argumentos, las coordenadas del origen. No se necesita ningún objeto para este formulario.
  • y1 — En forma de cuatro argumentos, las coordenadas del origen. No se necesita ningún objeto para este formulario.
  • x2 — En formularios con tres/cuatro argumentos, las coordenadas finales. No los confundas con serial del segundo objeto.
  • y2 — En formularios con tres/cuatro argumentos, las coordenadas finales. No los confundas con serial del segundo objeto.

Valor devuelto

int - max(abs(x2-x1), abs(y2-y1)): horizontal, vertical y diagonal a una celda adyacente tienen una distancia 1. No se tienen en cuenta la altura Z ni los obstáculos. Para la incógnita serial, la forma de un argumento devuelve 0; para un objeto existente en ausencia de un carácter: 65535. Para id1 desconocido, el formulario de tres argumentos usa (0,0), así que verifique Exists(id1) primero.

Comportamiento

  • La forma de un solo objeto utiliza el centro de rango actual World.RangeSize y la última posición en la cola de pasos de la mafia en movimiento. Durante el movimiento, el resultado puede diferir del cálculo realizado mediante GetX/GetY.
  • Los formularios de coordenadas funcionan con números pasados. Para las coordenadas del juego, use el rango 0..65535; Los valores int extremos y el desbordamiento de diferencia no son coordenadas admitidas.
  • El equipo no promete que el objetivo sea alcanzable. Para moverse, necesita MoveXY/NewMoveXY y verificar su resultado; Las paredes pueden hacer que el camino sea más largo.

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

1. Comprobar el alcance hasta el objetivo: guión directo

Parámetros y flujo de ejecución:

  • El objetivo es serial, no type. La comprobación Exists evita que el cero de un objeto desconocido se confunda con un objetivo cercano.
  • distancia<=2 comprueba el rango X/Y. La visibilidad y la transitabilidad se comprueban por separado.
var target = UO.GetSerial("lasttarget");
if (Truth(UO.Exists(target)))
{
    var distance = UO.GetDistance(target);
    if (Truth(distance <= 2))
    {
        UO.Print("Target is within two tiles");
    }
}

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

2. Distancia entre dos puntos - función de script

Parámetros y flujo de ejecución:

  • x1=100, y1=200, x2=103, y2=204. Las diferencias son 3 y 4.
  • El resultado es 4, no 7 ni el euclidiano 5.
return  RunScenario();
 object? RunScenario()
{
    var distance = UO.GetDistance(100, 200, 103, 204);
    UO.Print(Convert.ToString(distance));
    return null;
}

3. Comienza desde un objeto y desde tu personaje - clase de script

Parámetros y flujo de ejecución:

  • Los dos argumentos x/y usan la posición actual self. Los tres argumentos id1/x2/y2 le permiten especificar explícitamente el objeto inicial.
  • En una posición constante, ambas cantidades son iguales a 3. Las coordenadas deben permanecer dentro de los límites del mapa.
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() + 3;
        var y = UO.GetY() + 1;
        var fromSelf = UO.GetDistance(x, y);
        var fromObject = UO.GetDistance("self", x, y);
        UO.Print(Convert.ToString(fromSelf) + " / " + Convert.ToString(fromObject));
        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.GetDistance(id) — UO.GetDistance(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 "getdistance": return new InjectionValue(bridge.GetDistance(Arg(0)));

UO.GetDistance(id) — UO.GetDistance(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 GetDistance(int id) => bridge.GetDistance(id);

UO.GetDistance(id) — UO.GetDistance(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 GetDistance(string id) => GetDistance(GetObject(id));

UO.GetDistance(x, y) — UO.GetDistance(Integer,Integer)

Parámetros: x (Integer), y (Integer)

Resultado: int / Integer.

Durante la llamada:

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

public int GetDistance(int x, int y) => GetDistance(bridge.GetX(bridge.Self), bridge.GetY(bridge.Self), x, y);

UO.GetDistance(id1, x2, y2) — UO.GetDistance(Any,Any,Any)

Parámetros: id1 (Any), x2 (Any), y2 (Any)

Resultado: int / Integer.

Durante la llamada:

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

public int GetDistance(InjectionValue id1, InjectionValue x2, InjectionValue y2)

        {

            var obj1 = GetObject(id1);

            int x1 = bridge.GetX(obj1);

            int y1 = bridge.GetY(obj1);



            return GetDistance(x1, y1, NumberConversions.ToInt(x2), NumberConversions.ToInt(y2));

        }

UO.GetDistance(x1, y1, x2, y2) — UO.GetDistance(Integer,Integer,Integer,Integer)

Parámetros: x1 (Integer), y1 (Integer), x2 (Integer), y2 (Integer)

Resultado: int / Integer.

Durante la llamada:

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

public int GetDistance(int x1, int y1, int x2, int y2)

        {

            int dx = Math.Abs(x1 - x2);

            int dy = Math.Abs(y1 - y2);



            return Math.Max(dx, dy);

        }

UO.GetLandTileAt

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

Firmas de C#

dynamic UO.GetLandTileAt(object? x, object? y);
dynamic UO.GetLandTileAt(object? x, object? y, object? map);

Devuelve el registro de terreno extendido de la celda seleccionada.

Parámetros

  • x — Celda X del mapa actualmente cargado; coordenada mundial, no posición dentro del gump.
  • y — Celda Y del mapa actualmente cargado; coordenada mundial, no posición dentro del gump.
  • map — Número de tarjeta. Si este argumento no está presente en el formulario seleccionado, se utiliza el mapa actual. El cliente real sólo lee mosaicos del mapa actualmente cargado.

Valor devuelto

Matriz de campos 11 de un registro; los índices comienzan con 0:

  • [0] kind — string: "tierra", "estático" o "object".
  • [1] serial - int: serial elemento dinámico; para tierra/estático es 0.
  • [2] graphic - int: gráficos type.
  • [3] x, [4] y - int: coordenadas mundiales de la celda.
  • [5] z - int: la altura de la base en el mundo.
  • [6] hue - int: color, cerca del suelo 0.
  • [7] flags - int: bajo 32 bits de indicadores de datos de mosaico.
  • [8] name - string: nombre de Tiledata.
  • [9] layer - int: capa de equipo de Tiledata, cerca del suelo 0; no es un índice estático.
  • [10] height - int: altura graphic desde los datos del mosaico, cerca del suelo 0; no la coordenada Z.

Una matriz vacía [] significa que no hay entrada o que hay una tarjeta/celda inaccesible. Para GetStaticTileAt, un índice negativo/demasiado grande también produce []; El desbordamiento del índice no selecciona la entrada de otra persona.

Comportamiento

  • Los datos se refieren al mapa actualmente cargado. Otra tarjeta o celda inalcanzable da como resultado una matriz vacía. Las consultas directas en mosaico también pueden informar discrepancias en los mapas; GetWorldCell y GetWorldTilesArray devuelven inmediatamente una matriz vacía sin ese mensaje.
  • Los índices de matriz comienzan con 0. Marque ArrayLength antes de leer el campo. Z representa la altitud mundial; la capa es la propiedad del equipo de Tiledata y el índice es el número de serie de la entrada de la celda.

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

1. Lea type, Z y capas por separado: guión directo

Parámetros y flujo de ejecución:

  • x/y — posición del carácter; la tarjeta se baja y se selecciona automáticamente. Para GetStaticTileAt index=0 significa la primera entrada.
  • Los campos [2], [5], [9] tienen significados diferentes; todos se leen solo después de verificar la longitud de 11.
var tile = UO.GetLandTileAt(UO.GetX(), UO.GetY());
if (Truth(ArrayLength(tile) == 11))
{
    UO.Print("Type: " + Convert.ToString(tile[2]));
    UO.Print("World Z: " + Convert.ToString(tile[5]));
    UO.Print("Equipment layer: " + Convert.ToString(tile[9]));
}
else
{
    UO.Print("Tile is unavailable");
}

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. Obtener nombre y altura graphic - función de script

Parámetros y flujo de ejecución:

  • Se utilizan las mismas coordenadas; GetStaticTileAt lee índice=0.
  • mosaico[8] es la cadena del título, mosaico[10] es la dimensión de altura de los datos del mosaico, no la base Z.
return  RunScenario();
 object? RunScenario()
{
    var tile = UO.GetLandTileAt(UO.GetX(), UO.GetY());
    if (Truth(ArrayLength(tile) == 11))
    {
        UO.Print(tile[8]);
        UO.Print("Graphic height: " + Convert.ToString(tile[10]));
    }

    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. Preparar objetivo por type y coordenadas - clase de escenario

Parámetros y flujo de ejecución:

  • WaitTargetTile recibe graphic, x, y, z de los campos 2…5.
  • Esto es sólo una preparación para el próximo objetivo. El ejemplo no activa una herramienta o hechizo. serial=0 para estática no debe pasarse como ID del elemento.
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 tile = UO.GetLandTileAt(UO.GetX(), UO.GetY());
        if (Truth(ArrayLength(tile) == 11))
        {
            UO.WaitTargetTile(tile[2], tile[3], tile[4], tile[5]);
        }

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

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

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

Resultado: dynamic / Any.

Durante la llamada:

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

public InjectionValue GetLandTileAt(InjectionValue x, InjectionValue y)

            => GetLandTileAt(x, y, new InjectionValue(bridge.WorldNumber));

UO.GetLandTileAt(x, y, map) — UO.GetLandTileAt(Any,Any,Any)

Parámetros: x (Any), y (Any), map (Any)

Resultado: dynamic / Any.

Durante la llamada:

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

public InjectionValue GetLandTileAt(InjectionValue x, InjectionValue y, InjectionValue map)

        {

            int cellX = NumberConversions.ToInt(x);

            int cellY = NumberConversions.ToInt(y);

            int world = NumberConversions.ToInt(map);

            int[] land = bridge.GetLandscapeTile(cellX, cellY, world) ?? Array.Empty<int>();

            return land.Length >= 2

                ? BuildWorldTileRecord("land", 0, land[0], cellX, cellY, land[1], 0, 0)

                : new InjectionValue(Array.Empty<InjectionValue>());

        }

UO.GetLandTileData

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

Firmas de C#

dynamic UO.GetLandTileData(object? tile);

Lee el registro de referencia terrestre extendido de Tiledata.

Parámetros

  • tile es una entrada Gráfico/type, no serial ni un índice dentro de una celda. La tabla de terreno la elige el propio nombre del equipo.

Valor devuelto

Matriz de campos 7 para graphic válido. Todos los campos int excepto el nombre (string):

  • [0] graphic — graphic/type registros.
  • [1] flags: bits de bandera 32 de orden inferior.
  • [2] name: nombre de Tiledata (string).
  • [3] texId - ID texturas del suelo.
  • [4] wet — 1 si se instala húmedo, en caso contrario 0.
  • [5] impassable — 1 si es intransitable, en caso contrario 0.
  • [6] noDiagonal — 1 si noDiagonal, en caso contrario 0.

Para un graphic no válido no hay propiedades de referencia: se devuelve una matriz corta [переданный graphic, 0, ""]. Verifique la extensión completa antes de leer las propiedades. Este no es un registro de Pascal ni una lista de objetos.

Comportamiento

  • El comando lee datos de mosaicos y no requiere un elemento con ese graphic en el mundo. Las banderas describen el recurso; el resultado no reemplaza una verificación de ruta completa.

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

1. Leer nombre de entrada - guión directo

Parámetros y flujo de ejecución:

  • El mosaico es el número graphic de la tabla seleccionada.
  • data[2] contiene el nombre. La verificación de longitud separa una entrada completa de una entrada corta de un graphic no válido.
var data = UO.GetLandTileData(0x0003);
if (Truth(ArrayLength(data) == 7))
{
    UO.Print(data[2]);
}
else
{
    UO.Print("Tiledata entry is unavailable");
}

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. Verificar indicador booleano individual: función de secuencia de comandos

Parámetros y flujo de ejecución:

  • data[5] es un campo separado e intransitable: 1 (condición cumplida), 0 (condición no cumplida).
  • Esta verificación no tiene en cuenta otros objetos en la celda ni las habilidades del personaje.
return  RunScenario();
 object? RunScenario()
{
    var data = UO.GetLandTileData(0x0003);
    if (Truth(ArrayLength(data) == 7))
    {
        if (Truth(data[5]))
        {
            UO.Print("Impassable flag is set");
        }
        else
        {
            UO.Print("Impassable flag is not set");
        }
    }

    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. Imprimir graphic y la máscara de bandera general - clase de script

Parámetros y flujo de ejecución:

  • data[0] repite el graphic transmitido, data[1] es una máscara de bandera general.
  • La máscara puede contener varios bits al mismo tiempo; su valor numérico no es 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 data = UO.GetLandTileData(0x0003);
        if (Truth(ArrayLength(data) == 7))
        {
            UO.Print("Graphic: " + Convert.ToString(data[0]));
            UO.Print("Flags: " + Convert.ToString(data[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;
}

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.GetLandTileData(tile) — UO.GetLandTileData(Any)

Parámetros: tile (Any)

Resultado: dynamic / Any.

Durante la llamada:

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

case "getlandtiledata":

                    return BuildTileData(0, Arg(0));

UO.GetLandTilesArray

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

Firmas de C#

dynamic UO.GetLandTilesArray(object? xmin, object? ymin, object? xmax, object? ymax, object? worldNum, object? tileType);

Busca mosaicos de tierra en graphic/type en un rectángulo.

Parámetros

  • xmin — Coordenadas mundiales de dos ángulos, inclusive; 0...65535. Los ángulos reordenados están normalizados. Área no mayor a 1 000 000 celdas; Los límites no válidos provocan un error de secuencia de comandos antes de leer el mapa.
  • ymin — Coordenadas mundiales de dos ángulos, inclusive; 0...65535. Los ángulos reordenados están normalizados. Área no mayor a 1 000 000 celdas; Los límites no válidos provocan un error de secuencia de comandos antes de leer el mapa.
  • xmax — Coordenadas mundiales de dos ángulos, inclusive; 0...65535. Los ángulos reordenados están normalizados. Área no mayor a 1 000 000 celdas; Los límites no válidos provocan un error de secuencia de comandos antes de leer el mapa.
  • ymax — Coordenadas mundiales de dos ángulos, inclusive; 0...65535. Los ángulos reordenados están normalizados. Área no mayor a 1 000 000 celdas; Los límites no válidos provocan un error de secuencia de comandos antes de leer el mapa.
  • worldNum — Mapa/faceta 0..255; utilice UO.WorldNum(). Otro mapa muestra una matriz vacía. Si el mapa cambia entre fragmentos, el resultado parcial se descarta.
  • tileType - Un mosaico graphic/type, generalmente 0..65535; esto no es serial. 0 es exactamente graphic 0, -1 no significa ningún type. Un type que no coincide da un resultado en blanco.

Valor devuelto

Matriz de entradas [graphic, X, Y, Z]; todos los campos int. graphic - type de la tierra, Z - su fundamento. No hay coincidencias: matriz vacía. La cantidad es ArrayLength(resultado), no el resultado en sí. Los índices comienzan con 0. Este no es un registro bool, serial o Pascal; no hay un séptimo parámetro de salida.

Comportamiento

  • Se leen los datos locales. La búsqueda no cambia FindItem/FindCount y no realiza un movimiento, objetivo o comando de red.
  • Orden: X ascendente, dentro de X - Y ascendente. Los registros de una celda conservan el orden del puente; no está ordenado por distancia o altura.
  • La búsqueda se procesa en fragmentos de hasta 32 celdas con un presupuesto flexible de aproximadamente 1 ms. La cancelación se comprueba entre raciones. Una celda compleja o una lectura en frío pueden exceder el presupuesto. Es mejor dividir un área grande; El mundo puede cambiar mientras se lee.

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.GetLandTilesArray(UO.GetX(), UO.GetY(), UO.GetX() + 2, UO.GetY() + 2, UO.WorldNum(), 0x0003);
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

1. Buscar cerca de un personaje - guión directo

Parámetros y flujo de ejecución:

  • x/y - posición self, mapa - mapa actual. La región 3×3 incluye los límites. En el ejemplo se transmiten dos type, en forma normal uno. Cambie las muestras para adaptarlas a sus recursos; este es un objeto graphic, no un objeto ID.
var x = UO.GetX();
var y = UO.GetY();
var map = UO.WorldNum();
var rows = UO.GetLandTilesArray(x, y, x + 2, y + 2, map, 0x0003);
UO.Print("Records: " + Convert.ToString(ArrayLength(rows)));

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;

2. Ángulos reorganizados y salida de todos los campos: función de script

Parámetros y flujo de ejecución:

  • La región 2×2 se transfiere del ángulo mayor al menor. El propio algoritmo normaliza los límites. fila - un registro; PrintTile se declara en su totalidad y solo formatea números, sin mover nada. graphic - type, x/y - coordenadas, z - altura, hue - color. Para terrenos se pasa un condicional hue=0: no hay campo de color en el registro de terrenos.
return  RunScenario();
 object? RunScenario()
{
    var x = UO.GetX();
    var y = UO.GetY();
    var map = UO.WorldNum();
    var rows = UO.GetLandTilesArray(x + 1, y + 1, x, y, map, 0x0003);
    var i = 0;
    while (Truth(i < ArrayLength(rows)))
    {
        var row = rows[i];
        PrintTile(row[0], row[1], row[2], row[3], 0);
        i = i + 1;
    }

    return null;
}

void PrintTile(dynamic graphic, dynamic x, dynamic y, dynamic z, dynamic hue)
{
    UO.Print("Type=" + Convert.ToString(graphic) + " X=" + Convert.ToString(x) + " Y=" + Convert.ToString(y));
    UO.Print("Z=" + Convert.ToString(z) + " hue=" + Convert.ToString(hue));
}

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. Volver a sondear con límite de reintentos: clase de secuencia de comandos

Parámetros y flujo de ejecución:

  • No más de tres búsquedas por celda; entre intentos WaitAsync(250). Cada llamada crea un nuevo resultado. La longitud cero significa que no hay coincidencias ahora, en lugar de que el objeto desaparezca permanentemente 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 x = UO.GetX();
        var y = UO.GetY();
        var map = UO.WorldNum();
        var attempt = 0;
        while (Truth(attempt < 3))
        {
            var rows = UO.GetLandTilesArray(x, y, x, y, map, 0x0003);
            UO.Print("Records: " + Convert.ToString(ArrayLength(rows)));
            attempt = attempt + 1;
            await Delay(250);
        }

        return null;
    }

    int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
    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.GetLandTilesArray(xmin, ymin, xmax, ymax, worldNum, tileType) — UO.GetLandTilesArray(Any,Any,Any,Any,Any,Any)

Parámetros: xmin (Any), ymin (Any), xmax (Any), ymax (Any), worldNum (Any), tileType (Any)

Resultado: dynamic / Any.

Durante la llamada:

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

case "getlandtilesarray":

                    return FindPortableTiles(Arg(0), Arg(1), Arg(2), Arg(3), Arg(4), new[] { Arg(5) }, false);

UO.GetLandTilesArrayEx

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

Firmas de C#

dynamic UO.GetLandTilesArrayEx(object? xmin, object? ymin, object? xmax, object? ymax, object? worldNum, object? tileTypes);

Busca mosaicos de tierra en graphic/type en un rectángulo.

Parámetros

  • xmin — Coordenadas mundiales de dos ángulos, inclusive; 0...65535. Los ángulos reordenados están normalizados. Área no mayor a 1 000 000 celdas; Los límites no válidos provocan un error de secuencia de comandos antes de leer el mapa.
  • ymin — Coordenadas mundiales de dos ángulos, inclusive; 0...65535. Los ángulos reordenados están normalizados. Área no mayor a 1 000 000 celdas; Los límites no válidos provocan un error de secuencia de comandos antes de leer el mapa.
  • xmax — Coordenadas mundiales de dos ángulos, inclusive; 0...65535. Los ángulos reordenados están normalizados. Área no mayor a 1 000 000 celdas; Los límites no válidos provocan un error de secuencia de comandos antes de leer el mapa.
  • ymax — Coordenadas mundiales de dos ángulos, inclusive; 0...65535. Los ángulos reordenados están normalizados. Área no mayor a 1 000 000 celdas; Los límites no válidos provocan un error de secuencia de comandos antes de leer el mapa.
  • worldNum — Mapa/faceta 0..255; utilice UO.WorldNum(). Otro mapa muestra una matriz vacía. Si el mapa cambia entre fragmentos, el resultado parcial se descarta.
  • tileTypes — Matriz de números graphic/type; cada type coincidente está activado. Repetir type no duplica las entradas. El escalar también se toma como uno type. Matriz vacía lo significa todo type; una matriz de uno 0 busca solo 0.

Valor devuelto

Matriz de entradas [graphic, X, Y, Z]; todos los campos int. graphic - type de la tierra, Z - su fundamento. No hay coincidencias: matriz vacía. La cantidad es ArrayLength(resultado), no el resultado en sí. Los índices comienzan con 0. Este no es un registro bool, serial o Pascal; no hay un séptimo parámetro de salida.

Comportamiento

  • Se leen los datos locales. La búsqueda no cambia FindItem/FindCount y no realiza un movimiento, objetivo o comando de red.
  • Orden: X ascendente, dentro de X - Y ascendente. Los registros de una celda conservan el orden del puente; no está ordenado por distancia o altura.
  • La búsqueda se procesa en fragmentos de hasta 32 celdas con un presupuesto flexible de aproximadamente 1 ms. La cancelación se comprueba entre raciones. Una celda compleja o una lectura en frío pueden exceder el presupuesto. Es mejor dividir un área grande; El mundo puede cambiar mientras se lee.

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.GetLandTilesArrayEx(UO.X(), UO.Y(), UO.X() + 1, UO.Y() + 1, UO.WorldNum(), new[] { 0x0003 });
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

1. Buscar cerca de un personaje - guión directo

Parámetros y flujo de ejecución:

  • x/y - posición self, mapa - mapa actual. La región 3×3 incluye los límites. En el ejemplo se transmiten dos type, en forma normal uno. Cambie las muestras para adaptarlas a sus recursos; este es un objeto graphic, no un objeto ID.
dynamic[] types = new dynamic[checked((int)(1) + 1)];
types[0] = 0x0003;
types[1] = 0x0004;
var x = UO.GetX();
var y = UO.GetY();
var map = UO.WorldNum();
var rows = UO.GetLandTilesArrayEx(x, y, x + 2, y + 2, map, types);
UO.Print("Records: " + Convert.ToString(ArrayLength(rows)));

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;

2. Ángulos reorganizados y salida de todos los campos: función de script

Parámetros y flujo de ejecución:

  • La región 2×2 se transfiere del ángulo mayor al menor. El propio algoritmo normaliza los límites. fila - un registro; PrintTile se declara en su totalidad y solo formatea números, sin mover nada. graphic - type, x/y - coordenadas, z - altura, hue - color. Para terrenos se pasa un condicional hue=0: no hay campo de color en el registro de terrenos.
return  RunScenario();
 object? RunScenario()
{
    dynamic[] types = new dynamic[checked((int)(1) + 1)];
    types[0] = 0x0003;
    types[1] = 0x0004;
    var x = UO.GetX();
    var y = UO.GetY();
    var map = UO.WorldNum();
    var rows = UO.GetLandTilesArrayEx(x + 1, y + 1, x, y, map, types);
    var i = 0;
    while (Truth(i < ArrayLength(rows)))
    {
        var row = rows[i];
        PrintTile(row[0], row[1], row[2], row[3], 0);
        i = i + 1;
    }

    return null;
}

void PrintTile(dynamic graphic, dynamic x, dynamic y, dynamic z, dynamic hue)
{
    UO.Print("Type=" + Convert.ToString(graphic) + " X=" + Convert.ToString(x) + " Y=" + Convert.ToString(y));
    UO.Print("Z=" + Convert.ToString(z) + " hue=" + Convert.ToString(hue));
}

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. Volver a sondear con límite de reintentos: clase de secuencia de comandos

Parámetros y flujo de ejecución:

  • No más de tres búsquedas por celda; entre intentos WaitAsync(250). Cada llamada crea un nuevo resultado. La longitud cero significa que no hay coincidencias ahora, en lugar de que el objeto desaparezca permanentemente 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()
    {
        dynamic[] types = new dynamic[checked((int)(1) + 1)];
        types[0] = 0x0003;
        types[1] = 0x0004;
        var x = UO.GetX();
        var y = UO.GetY();
        var map = UO.WorldNum();
        var attempt = 0;
        while (Truth(attempt < 3))
        {
            var rows = UO.GetLandTilesArrayEx(x, y, x, y, map, types);
            UO.Print("Records: " + Convert.ToString(ArrayLength(rows)));
            attempt = attempt + 1;
            await Delay(250);
        }

        return null;
    }

    int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
    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.GetLandTilesArrayEx(xmin, ymin, xmax, ymax, worldNum, tileTypes) — UO.GetLandTilesArrayEx(Any,Any,Any,Any,Any,Any)

Parámetros: xmin (Any), ymin (Any), xmax (Any), ymax (Any), worldNum (Any), tileTypes (Any)

Resultado: dynamic / Any.

Durante la llamada:

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

case "getlandtilesarrayex":

                    return FindPortableTiles(Arg(0), Arg(1), Arg(2), Arg(3), Arg(4), ArrayArg(5), false);

UO.GetLandscapeTile

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

Firmas de C#

dynamic UO.GetLandscapeTile(object? x, object? y, object? map);

Lee la tierra de una celda de la tarjeta actual.

Parámetros

  • x — Celda X del mapa actualmente cargado; coordenada mundial, no posición dentro del gump.
  • y — Celda Y del mapa actualmente cargado; coordenada mundial, no posición dentro del gump.
  • map — Número de tarjeta. Si este argumento no está presente en el formulario seleccionado, se utiliza el mapa actual. El cliente real sólo lee mosaicos del mapa actualmente cargado.

Valor devuelto

Conjunto de tres tierras int: [0] graphic - type; [1] z — altitud mundial de la tierra; [2] flags: bits bajos de 32 de indicadores de datos de mosaico. Si la tarjeta/loseta no está disponible o no hay tierra, se devuelve una matriz vacía []. Este es un registro plano, no una lista de tres mosaicos.

Comportamiento

  • Los datos se refieren al mapa actualmente cargado. Otra tarjeta o celda inalcanzable da como resultado una matriz vacía. Las consultas directas en mosaico también pueden informar discrepancias en los mapas; GetWorldCell y GetWorldTilesArray devuelven inmediatamente una matriz vacía sin ese mensaje.
  • Los índices de matriz comienzan con 0. Marque ArrayLength antes de leer el campo. Z representa la altitud mundial; la capa es la propiedad del equipo de Tiledata y el índice es el número de serie de la entrada de la celda.

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

1. Mostrar el terreno debajo del personaje - guión directo

Parámetros y flujo de ejecución:

  • x/y se toman de la posición del personaje; map=WorldNum() selecciona el mapa actual.
  • La presencia de tres campos se verifica antes de la indexación; tierra[0] - graphic, tierra[1] - Z.
var land = UO.GetLandscapeTile(UO.GetX(), UO.GetY(), UO.WorldNum());
if (Truth(ArrayLength(land) >= 3))
{
    UO.Print("Graphic: " + Convert.ToString(land[0]));
    UO.Print("Ground Z: " + Convert.ToString(land[1]));
}
else
{
    UO.Print("Land is unavailable");
}

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. Comparar la altura de la celda vecina - función de script

Parámetros y flujo de ejecución:

  • x+1 es una celda vecina, y y el mapa se conservan.
  • deltaZ compara terreno y carácter. Esta no es una prueba de pasabilidad: los puentes y la estática se cuentan por separado.
return  RunScenario();
 object? RunScenario()
{
    var land = UO.GetLandscapeTile(UO.GetX() + 1, UO.GetY(), UO.WorldNum());
    if (Truth(ArrayLength(land) >= 3))
    {
        var deltaZ = land[1] - UO.GetZ();
        UO.Print("Ground height difference: " + Convert.ToString(deltaZ));
    }

    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. Lea el nombre de la tierra encontrada - clase de escenario

Parámetros y flujo de ejecución:

  • grupo=0 selecciona terreno; tierra[0] — graphic.
  • GetTileName devuelve texto, mientras que GetLandscapeTile devuelve una matriz.
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 land = UO.GetLandscapeTile(UO.GetX(), UO.GetY(), UO.WorldNum());
        if (Truth(ArrayLength(land) >= 3))
        {
            var name = UO.GetTileName(0, land[0]);
            UO.Print(name);
        }

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

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.GetLandscapeTile(x, y, map) — UO.GetLandscapeTile(Any,Any,Any)

Parámetros: x (Any), y (Any), map (Any)

Resultado: dynamic / Any.

Durante la llamada:

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

public InjectionValue GetLandscapeTile(InjectionValue x, InjectionValue y, InjectionValue map)

            => ToArray(bridge.GetLandscapeTile(NumberConversions.ToInt(x), NumberConversions.ToInt(y), NumberConversions.ToInt(map)));

UO.GetLayerCount

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

Firmas de C#

dynamic UO.GetLayerCount(object? x, object? y, object? worldNum);

Cuenta registros de geometría no terrestre en una celda.

Parámetros

  • x — Coordenada mundial X de la celda del mapa actual, no la posición en el gump.
  • y — Coordenada mundial Y de la celda del mapa actual.
  • worldNum — Número de tarjeta/faceta; utilice UO.WorldNum(). Sólo se lee la tarjeta actualmente cargada.

Valor devuelto

int — número de triples graphic/Z/hue recibidos por GetStaticTiles. En el cliente actual, se tienen en cuenta Estático, Múltiple y Artículo: varios registros de la misma altura se cuentan por separado. Un cuadrado vacío/otra carta da 0. Este no es el número de capa de equipo, el número de pisos, el número de alturas únicas o bool.

Comportamiento

  • El comando lee el mapa local y no activa movimiento ni objetivo. Una celda fuera del tamaño del mapa no se reemplaza por una celda en una columna adyacente.
  • La altura de Z, graphic/type, el color de hue, las banderas y la capa de equipo tienen diferentes significados. Nulo graphic o Z=0 pueden ser datos válidos; consulte el formulario de resultados.
  • La composición corresponde a ReadStaticsXY, no a GetLayer o ObjAtLayer. Este cliente incluye elementos dinámicos y piezas múltiples.

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

1. Contar registros bajo un carácter - guión directo

Parámetros y flujo de ejecución:

  • recuento: número de registros de celda; 1 significa una entrada, no un éxito lógico.
var count = UO.GetLayerCount(UO.GetX(), UO.GetY(), UO.WorldNum());
UO.Print("Tile records: " + Convert.ToString(count));

2. Verificar celda adyacente - función de script

Parámetros y flujo de ejecución:

  • La ausencia de registros no prueba el paso de tierra. La presencia de una grabación tampoco prueba que se trate de una pared.
return  RunScenario();
 object? RunScenario()
{
    var x = UO.GetX() + 1;
    var y = UO.GetY();
    var count = UO.GetLayerCount(x, y, UO.WorldNum());
    if (Truth(count > 0))
    {
        UO.Print("Non-land geometry exists: " + Convert.ToString(count));
    }
    else
    {
        UO.Print("No loaded non-land records");
    }

    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 contenido de dos capas de mapa: clase de secuencia de comandos

Parámetros y flujo de ejecución:

  • Se verifican las celdas actuales y vecinas en el mismo mundo. El número de capas no es su altura o 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()
    {
        int x = UO.GetX();
        int y = UO.GetY();
        int world = UO.WorldNum();
        int land = UO.GetLayerCount(x, y, world);
        int nearby = UO.GetLayerCount(x + 1, y, world);
        UO.Print($"Layers here: {land}; adjacent tile: {nearby}");
        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.GetLayerCount(x, y, worldNum) — UO.GetLayerCount(Any,Any,Any)

Parámetros: x (Any), y (Any), worldNum (Any)

Resultado: dynamic / Any.

Durante la llamada:

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

case "getlayercount":

                    // Stealth's deprecated GetLayerCount(X,Y,WorldNum) is the

                    // number of static records at a map cell.  The portable

                    // bridge returns each record as Graphic/Z/Hue triples.

                    return new InjectionValue(bridge.GetStaticTiles(Arg(0), Arg(1), Arg(2)).Length / 3);

UO.GetMapCell

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

Firmas de C#

dynamic UO.GetMapCell(object? x, object? y, object? worldNum);

Lee graphic, altura y banderas de tierra en un cuadrado del mapa.

Parámetros

  • x — Coordenada mundial X de la celda del mapa actual, no la posición en el gump.
  • y — Coordenada mundial Y de la celda del mapa actual.
  • worldNum — Número de tarjeta/faceta; utilice UO.WorldNum(). Sólo se lee la tarjeta actualmente cargada.

Valor devuelto

Conjunto de tres int: [0] graphic/type tierras, [1] tierras de bases mundiales Z, [2] bits menores 32 de banderas de datos de mosaicos. Una celda u otra tarjeta inaccesible da como resultado una matriz vacía. Este no es un registro serial, bool o Pascal; no utilice campos .Tile/.Z. Para conocer la cantidad de campos, llame a ArrayLength(celda).

Comportamiento

  • El comando lee el mapa local y no activa movimiento ni objetivo. Una celda fuera del tamaño del mapa no se reemplaza por una celda en una columna adyacente.
  • La altura de Z, graphic/type, el color de hue, las banderas y la capa de equipo tienen diferentes significados. Nulo graphic o Z=0 pueden ser datos válidos; consulte el formulario de resultados.

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

1. Leer el terreno debajo del personaje - guión directo

Parámetros y flujo de ejecución:

  • X/Y se toman de self, WorldNum es la tarjeta actual. La celda almacena todos los campos de una llamada.
  • Los índices comienzan con 0. la celda[1] es la altura, no una señal de una búsqueda exitosa; Se verifica una matriz vacía antes de la indexación.
var cell = UO.GetMapCell(UO.GetX(), UO.GetY(), UO.WorldNum());
if (Truth(ArrayLength(cell) == 3))
{
    UO.Print("Type: " + Convert.ToString(cell[0]));
    UO.Print("Land Z: " + Convert.ToString(cell[1]));
    UO.Print("Flags: " + Convert.ToString(cell[2]));
}
else
{
    UO.Print("Map cell unavailable");
}

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. Comparar dos celdas adyacentes - función de script

Parámetros y flujo de ejecución:

  • La segunda llamada lee el cuadrado del este, ambos usando la misma tarjeta.
  • La diferencia de altura del terreno no demuestra la transitabilidad: las paredes, la estática y otros objetos se controlan por separado.
return  RunScenario();
 object? RunScenario()
{
    var x = UO.GetX();
    var y = UO.GetY();
    var map = UO.WorldNum();
    var here = UO.GetMapCell(x, y, map);
    var east = UO.GetMapCell(x + 1, y, map);
    if (Truth(ArrayLength(here) == 3) && Truth(ArrayLength(east) == 3))
    {
        UO.Print("Land difference: " + Convert.ToString(east[1] - here[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. Comparar la base de la Tierra con la superficie promedio - Clase de script

Parámetros y flujo de ejecución:

  • GetMapCell lee Land.Z; GetSurfaceZ lee Land.AverageZ.
  • Ambos valores son altura. En terrenos inclinados pueden variar; Esta no es la altura del piso de la casa.
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 map = UO.WorldNum();
        var cell = UO.GetMapCell(x, y, map);
        if (Truth(ArrayLength(cell) == 3))
        {
            var average = UO.GetSurfaceZ(x, y, map);
            UO.Print("Base: " + Convert.ToString(cell[1]) + ", average: " + Convert.ToString(average));
        }

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

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.GetMapCell(x, y, worldNum) — UO.GetMapCell(Any,Any,Any)

Parámetros: x (Any), y (Any), worldNum (Any)

Resultado: dynamic / Any.

Durante la llamada:

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

case "getmapcell":

                    return new InjectionValue(bridge.GetLandscapeTile(Arg(0), Arg(1), Arg(2))

                        .Select(value => new InjectionValue(value)).ToArray());

UO.GetNextStepZ

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

Firmas de C#

int UO.GetNextStepZ(object? currX, object? currY, object? destX, object? destY, object? worldNum, object? currZ);

Calcula la altura estimada del siguiente paso en la dirección especificada.

Parámetros

  • currX — Mundo inicial X, normalmente UO.GetX().
  • currY — Mundo inicial Y, normalmente UO.GetY().
  • destX — X destino. Para verificar un paso específico, pase la celda adyacente.
  • destY — Y destino; junto con DestX, establece la dirección de un paso, en lugar de la ruta completa.
  • worldNum — Número de tarjeta/faceta; utilice UO.WorldNum(). Sólo se lee la tarjeta actualmente cargada.
  • currZ — Altura inicial Z, normalmente UO.GetZ(); El cálculo geométrico utiliza el rango -128...127.

Valor devuelto

int — Z calculado del siguiente paso; 0 y los números negativos son alturas válidas. Cuando un personaje u otra carta 0 está deshabilitada. El método devuelve el componente Z de la verificación incluso si falla; el número en sí no es una confirmación de paso. Para bandera y altura juntas, use IsWorldCellPassable y lea [0]/[1].

Comportamiento

  • El comando lee el mapa local y no activa movimiento ni objetivo. Una celda fuera del tamaño del mapa no se reemplaza por una celda en una columna adyacente.
  • La altura de Z, graphic/type, el color de hue, las banderas y la capa de equipo tienen diferentes significados. Nulo graphic o Z=0 pueden ser datos válidos; consulte el formulario de resultados.
  • El cálculo no da un paso y no abre la puerta. Comprueba la geometría local; el servidor puede rechazar el movimiento real. Si el puente no devuelve Z, se utiliza CurrZ.

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.GetNextStepZ(UO.GetX(), UO.GetY(), UO.GetX() + 1, UO.GetY(), UO.WorldNum(), UO.GetZ());
UO.Print("GetNextStepZ: " + Convert.ToString(result));

1. Descubra la altura estimada del escalón oriental - guión directo

Parámetros y flujo de ejecución:

  • Seis parámetros: X/Y original, X/Y adyacente, mapa y Z original. nextZ es la altura, no true/false.
var x = UO.GetX();
var y = UO.GetY();
var z = UO.GetZ();
var nextZ = UO.GetNextStepZ(x, y, x + 1, y, UO.WorldNum(), z);
UO.Print("Candidate Z: " + Convert.ToString(nextZ));

2. Viaje separado de la altitud real 0 - función de script

Parámetros y flujo de ejecución:

  • La llamada se realiza sólo cuando existe una conexión conocida. Entre la verificación y la lectura, es posible que se pierda la conexión; Z=0 todavía no es un código de éxito.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(Truth(UO.Connected()) == true))
    {
        var x = UO.GetX();
        var y = UO.GetY();
        var z = UO.GetNextStepZ(x, y, x, y + 1, UO.WorldNum(), UO.GetZ());
        UO.Print("South candidate Z: " + Convert.ToString(z));
    }
    else
    {
        UO.Print("Character disconnected");
    }

    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 el siguiente paso desde la altura actual: clase de script

Parámetros y flujo de ejecución:

  • Las coordenadas de las celdas de origen y de destino se transmiten por separado. El resultado es la altura esperada, incluso con obstrucción; la bandera de paso muestra por separado IsWorldCellPassable.
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()
    {
        int x = UO.GetX();
        int y = UO.GetY();
        int z = UO.GetZ();
        int nextZ = UO.GetNextStepZ(x, y, x + 1, y, UO.WorldNum(), z);
        UO.Print($"Current height: {z}; next-step result: {nextZ}");
        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.GetNextStepZ(currX, currY, destX, destY, worldNum, currZ) — UO.GetNextStepZ(Any,Any,Any,Any,Any,Any)

Parámetros: currX (Any), currY (Any), destX (Any), destY (Any), worldNum (Any), currZ (Any)

Resultado: int / Integer.

Durante la llamada:

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

case "getnextstepz":

                {

                    if (bridge.IsOnline() == 0 || Arg(4) != bridge.WorldNumber)

                        return new InjectionValue(0);

                    int[] step = bridge.CheckWorldStep(Arg(0), Arg(1), Arg(5), Arg(2), Arg(3), Arg(4));

                    return new InjectionValue(step.Length > 1 ? step[1] : Arg(5));

                }

UO.GetStaticArt

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

Firmas de C#

dynamic UO.GetStaticArt(object? objType, object? hue);

Obtiene una única imagen gráfica de los archivos gráficos de Ultima Online instalados y la devuelve a la memoria en formato BMP. Útil para comprobar los recursos del juego, los tamaños de los iconos, leer el color de los píxeles y comparar versiones coloreadas de un elemento. El comando en sí no abre una ventana, no guarda un archivo ni busca elementos en el mundo.

Parámetros

  • objType — Gráfico obligatorio/type de la sección de arte estático: entero 0..65535, una cadena con ese número o un nombre almacenado AddType. Por ejemplo, 0x0EED es un arte para una pila de oro. Este no es el serial, la coordenada de mapa/mosaico o el número de animación del cuerpo del elemento. Para obtener el arte de un elemento cargado, pase UO.GetType(item), donde el elemento es su serial. Cuando el número type está fuera de rango, el resultado es una matriz vacía; un nombre de cadena desconocido provoca un error de conversión.
  • hue — Valor de color entero obligatorio: 0 — colores originales del arte; un valor positivo es hue de los archivos del cliente. Se aceptan cadenas numéricas, incluido el resultado UO.GetColor(item). El valor está limitado al rango 0..65535: negativo se convierte en 0, demasiado grande se convierte en 65535. Aquí -1 NO significa ningún color. El arte de la bandera PartialHue utiliza coloración parcial; para otros, completo. El resultado de un hue particular depende de la tabla de colores cargada.

Valor devuelto

La matriz es una matriz unidimensional int, cada elemento 0..255 representa un byte del archivo BMP completo, comenzando con el encabezado. Indexación con 0. No es bool, ni ID, ni una ruta, ni un objeto de mapa de bits, ni una matriz de colores RGB. Una matriz vacía significa que el número type no es válido, falta el arte o los archivos necesarios del juego no están cargados. Antes de leer el título, marque ArrayLength; la matriz vacía no es igual al número 0.

Comportamiento

  • Se requieren exactamente dos argumentos. La lectura se realiza desde los recursos locales del cliente, sin solicitud al servidor. No se requiere la existencia de un objeto en el mundo. Para mobile, un número de GetType significa body; aquí el mismo número aborda una sección de recursos diferente y no proporciona una imagen de la animación del personaje.
  • Formato de resultado: 24-bit BMP sin comprimir. Bytes [0]=66 y [1]=77 - BM; [2..5] - tamaño de todo el archivo; [10..13] - el comienzo de los píxeles, ahora 54; [14..17] - tamaño del encabezado DIB, ahora 40; [18..21] - ancho; [22..25] - altura positiva; [26..27] - 1 avión; [28..29] - 24 bit. Los números multibyte se escriben en little endian.
  • Cada píxel ocupa tres bytes en el orden B, G, R. Las líneas van de abajo hacia arriba y se rellenan con cero bytes hasta un múltiplo de 4. Longitud de la cadena = Int((ancho * 3 + 3) / 4) * 4. Para las coordenadas x,y desde la esquina superior izquierda, desplazamiento = 54 + (altura - 1 - y) * zancada + x * 3. Verifique los límites y el tamaño de la matriz antes de acceder.
  • La transparencia del arte original no se conserva: BMP no contiene alfa aquí. El fondo transparente se vuelve negro y es imposible distinguirlo del píxel negro original por el resultado. La captura de pantalla, la escala de la ventana del juego, la luz, el rango de visibilidad y las coordenadas del objeto no están involucrados.
  • Para cada llamada, se genera una matriz de imágenes. Si necesita arte muchas veces, guarde el resultado en una variable y procéselo nuevamente. No llame a cargar/colorear para cada píxel dentro del bucle. Los mismos parámetros y archivos sin cambios dan el mismo resultado; No es necesario que hue diferentes cambien cada píxel, especialmente con PartialHue.
  • Un .bmp real necesita una salida binaria de los bytes exactos sin codificación de texto. Un archivo normal.WriteLine o JsonSave no crea BMP. Los ejemplos siguientes procesan la matriz en la memoria y no prometen la presencia de un archivo inexistente.WriteBytes.

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

1. Verifique el tamaño del ícono antes de procesarlo usted mismo: secuencia de comandos directa

Parámetros y flujo de ejecución:

  • ObjType=0x0EED selecciona el recurso, Hue=0 deja los colores originales. La matriz se verifica antes de leer las compensaciones 18 y 22. 64 es el límite propio del ejemplo, no un límite de comando.
  • ArtSizeField es una función C# definida por el usuario, no un comando UO. Agrega cuatro bytes con pesos 1, 256, 65536, 16777216. El script te ayuda a elegir el tamaño de tu celda; No crea un gump automáticamente.
var bmp = UO.GetStaticArt(0x0EED, 0);
if (Truth(ArrayLength(bmp) < 54))
{
    UO.Print("Gold art is unavailable");
    return null;
}
var width = ArtSizeField(bmp, 18);
var height = ArtSizeField(bmp, 22);
if (Truth(width > 64) || Truth(height > 64))
{
    UO.Print("Use a larger cell for this icon");
    return null;
}
UO.Print("Icon fits: " + Convert.ToString(width) + " x " + Convert.ToString(height));

dynamic ArtSizeField(dynamic bytes, dynamic offset)
{
    return bytes[offset] + bytes[offset+1]*256 + bytes[offset+2]*65536 + bytes[offset+3]*16777216;
}

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. Calcular RGB de un píxel teniendo en cuenta las líneas invertidas BMP - función de script

Parámetros y flujo de ejecución:

  • GetStaticArt devuelve BMP; ArtPixelRGB es una función de ejemplo independiente para este formato. x=0,y=0 significa el píxel superior izquierdo de la imagen, no las coordenadas mundiales. Se requiere la altura de reemplazo-1-y debido al orden de las líneas de abajo hacia arriba.
  • La función devuelve RGB int 0..16777215 y utiliza -1 solo como indicador de la ausencia de un píxel. El negro 0 es un color válido, no false y no es un error. Por lo tanto, la prueba para si rgb < 0 es independiente de si rgb = 0.
return  RunScenario();
 object? RunScenario()
{
    var bmp = UO.GetStaticArt(0x0EED, 0);
    var rgb = ArtPixelRGB(bmp, 0, 0);
    if (Truth(rgb < 0))
    {
        UO.Print("No pixel at this position");
        return null;
    }

    if (Truth(rgb == 0))
    {
        UO.Print("Black pixel: may also be the original transparent background");
    }

    return null;
}

dynamic ArtPixelRGB(dynamic bmp, dynamic x, dynamic y)
{
    if (Truth(ArrayLength(bmp) < 54))
    {
        return -1;
    }

    var width = bmp[18] + bmp[19] * 256 + bmp[20] * 65536 + bmp[21] * 16777216;
    var height = bmp[22] + bmp[23] * 256 + bmp[24] * 65536 + bmp[25] * 16777216;
    if (Truth(x < 0) || Truth(y < 0) || Truth(x >= width) || Truth(y >= height))
    {
        return -1;
    }

    var stride = Math.Floor((width * 3 + 3) / 4) * 4;
    var offset = 54 + (height - 1 - y) * stride + x * 3;
    if (Truth(offset + 2 >= ArrayLength(bmp)))
    {
        return -1;
    }

    return bmp[offset + 2] * 65536 + bmp[offset + 1] * 256 + bmp[offset];
}

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. Compara versiones originales y coloreadas del mismo arte - clase de guión

Parámetros y flujo de ejecución:

  • 0x1F03 — Túnicas gráficas; 0 y 0x0044 son el hue original y seleccionado. El mismo gráfico da las mismas dimensiones. Si el resultado está vacío, la comparación no comienza.
  • cambiado cuenta diferentes bytes de canales de color, no objetos o número de píxeles. Un píxel puede cambiar hasta tres bytes. PartialHue, la tabla de colores y los colores originales pueden dejar parte o la totalidad de la imagen igual; Esto no es evidencia de un error del equipo.
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 original = UO.GetStaticArt(0x1F03, 0);
        var colored = UO.GetStaticArt(0x1F03, 0x0044);
        var size = ArrayLength(original);
        if (Truth(size < 54) || Truth(size != ArrayLength(colored)))
        {
            UO.Print("Cannot compare these art resources");
            return null;
        }

        var changed = 0;
        for (int offset = (int)(54); offset <= size - 1; offset += (int)(1))
        {
            if (Truth(original[offset] != colored[offset]))
            {
                changed = changed + 1;
            }
        }

        if (Truth(changed == 0))
        {
            UO.Print("This hue did not change the exported bytes");
        }
        else
        {
            UO.Print("Changed color bytes: " + Convert.ToString(changed));
        }

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

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.GetStaticArt(objType, hue) — UO.GetStaticArt(Any,Any)

Parámetros: objType (Any), hue (Any)

Resultado: dynamic / Any.

Durante la llamada:

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

case "getstaticart":

                    return new InjectionValue(bridge.GetStaticArt(ResolveType(arguments[0]), Arg(1)).Select(value => new InjectionValue(value)).ToArray());

UO.GetStaticTileAt

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

Firmas de C#

dynamic UO.GetStaticTileAt(object? x, object? y, object? index);
dynamic UO.GetStaticTileAt(object? x, object? y, object? map, object? index);

Devuelve un registro extendido de un único registro sobre el suelo de la celda seleccionada.

Parámetros

  • x — Celda X del mapa actualmente cargado; coordenada mundial, no posición dentro del gump.
  • y — Celda Y del mapa actualmente cargado; coordenada mundial, no posición dentro del gump.
  • map — Número de tarjeta. Si este argumento no está presente en el formulario seleccionado, se utiliza el mapa actual. El cliente real sólo lee mosaicos del mapa actualmente cargado.
  • index: el número de secuencia del registro en los resultados GetStaticTiles, comenzando con 0. Esto no es graphic, ni Z, ni una capa de equipo. En la forma de argumentos 3, el índice ocupa el tercer lugar; en forma de 4 los argumentos se asignan en tercer lugar, el índice en cuarto lugar.

Valor devuelto

Matriz de campos 11 de un registro; los índices comienzan con 0:

  • [0] kind — string: "tierra", "estático" o "object".
  • [1] serial - int: serial elemento dinámico; para tierra/estático es 0.
  • [2] graphic - int: gráficos type.
  • [3] x, [4] y - int: coordenadas mundiales de la celda.
  • [5] z - int: la altura de la base en el mundo.
  • [6] hue - int: color, cerca del suelo 0.
  • [7] flags - int: bajo 32 bits de indicadores de datos de mosaico.
  • [8] name - string: nombre de Tiledata.
  • [9] layer - int: capa de equipo de Tiledata, cerca del suelo 0; no es un índice estático.
  • [10] height - int: altura graphic desde los datos del mosaico, cerca del suelo 0; no la coordenada Z.

Una matriz vacía [] significa que no hay entrada o que hay una tarjeta/celda inaccesible. Para GetStaticTileAt, un índice negativo/demasiado grande también produce []; El desbordamiento del índice no selecciona la entrada de otra persona.

Comportamiento

  • Los datos se refieren al mapa actualmente cargado. Otra tarjeta o celda inalcanzable da como resultado una matriz vacía. Las consultas directas en mosaico también pueden informar discrepancias en los mapas; GetWorldCell y GetWorldTilesArray devuelven inmediatamente una matriz vacía sin ese mensaje.
  • Los índices de matriz comienzan con 0. Marque ArrayLength antes de leer el campo. Z representa la altitud mundial; la capa es la propiedad del equipo de Tiledata y el índice es el número de serie de la entrada de la celda.

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

1. Lea type, Z y capas por separado: guión directo

Parámetros y flujo de ejecución:

  • x/y — posición del carácter; la tarjeta se baja y se selecciona automáticamente. Para GetStaticTileAt index=0 significa la primera entrada.
  • Los campos [2], [5], [9] tienen significados diferentes; todos se leen solo después de verificar la longitud de 11.
var tile = UO.GetStaticTileAt(UO.GetX(), UO.GetY(), 0);
if (Truth(ArrayLength(tile) == 11))
{
    UO.Print("Type: " + Convert.ToString(tile[2]));
    UO.Print("World Z: " + Convert.ToString(tile[5]));
    UO.Print("Equipment layer: " + Convert.ToString(tile[9]));
}
else
{
    UO.Print("Tile is unavailable");
}

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. Obtener nombre y altura graphic - función de script

Parámetros y flujo de ejecución:

  • Se utilizan las mismas coordenadas; GetStaticTileAt lee índice=0.
  • mosaico[8] es la cadena del título, mosaico[10] es la dimensión de altura de los datos del mosaico, no la base Z.
return  RunScenario();
 object? RunScenario()
{
    var tile = UO.GetStaticTileAt(UO.GetX(), UO.GetY(), 0);
    if (Truth(ArrayLength(tile) == 11))
    {
        UO.Print(tile[8]);
        UO.Print("Graphic height: " + Convert.ToString(tile[10]));
    }

    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. Preparar objetivo por type y coordenadas - clase de escenario

Parámetros y flujo de ejecución:

  • WaitTargetTile recibe graphic, x, y, z de los campos 2…5.
  • Esto es sólo una preparación para el próximo objetivo. El ejemplo no activa una herramienta o hechizo. serial=0 para estática no debe pasarse como ID del elemento.
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 tile = UO.GetStaticTileAt(UO.GetX(), UO.GetY(), 0);
        if (Truth(ArrayLength(tile) == 11))
        {
            UO.WaitTargetTile(tile[2], tile[3], tile[4], tile[5]);
        }

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

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.GetStaticTileAt(x, y, index) — UO.GetStaticTileAt(Any,Any,Any)

Parámetros: x (Any), y (Any), index (Any)

Resultado: dynamic / Any.

Durante la llamada:

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

public InjectionValue GetStaticTileAt(InjectionValue x, InjectionValue y, InjectionValue index)

            => GetStaticTileAt(x, y, new InjectionValue(bridge.WorldNumber), index);

UO.GetStaticTileAt(x, y, map, index) — UO.GetStaticTileAt(Any,Any,Any,Any)

Parámetros: x (Any), y (Any), map (Any), index (Any)

Resultado: dynamic / Any.

Durante la llamada:

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

public InjectionValue GetStaticTileAt(InjectionValue x, InjectionValue y, InjectionValue map, InjectionValue index)

        {

            int cellX = NumberConversions.ToInt(x);

            int cellY = NumberConversions.ToInt(y);

            int[] statics = bridge.GetStaticTiles(cellX, cellY, NumberConversions.ToInt(map)) ?? Array.Empty<int>();

            int tileIndex = NumberConversions.ToInt(index);

            if (tileIndex < 0 || tileIndex >= statics.Length / 3)

                return new InjectionValue(Array.Empty<InjectionValue>());

            int offset = tileIndex * 3;

            return offset + 2 < statics.Length

                ? BuildWorldTileRecord("static", 0, statics[offset], cellX, cellY, statics[offset + 1], statics[offset + 2], 1)

                : new InjectionValue(Array.Empty<InjectionValue>());

        }

UO.GetStaticTileData

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

Firmas de C#

dynamic UO.GetStaticTileData(object? tile);

Lee la entrada de referencia extendida estática graphic de Tiledata.

Parámetros

  • tile es una entrada Gráfico/type, no serial ni un índice dentro de una celda. La tabla estática se selecciona por el propio nombre del comando.

Valor devuelto

Matriz de campos 17 para graphic válido. Todos los campos int excepto el nombre (string):

  • [0] graphic — graphic/type registros.
  • [1] flags: bits de bandera 32 de orden inferior.
  • [2] name: nombre de Tiledata (string).
  • [3] weight: peso de los datos del mosaico.
  • [4] layer — número de capa de equipo.
  • [5] count es el campo Count de Tiledata, no la cantidad de elementos en el mundo.
  • Animaciones [6] animId - ID.
  • [7] hue — hue de Tiledata.
  • [8] lightIndex — índice de la fuente de luz.
  • [9] height - altura graphic, no altura mundial Z.
  • [10] wet — 1 si se instala húmedo, en caso contrario 0.
  • [11] impassable — 1 si es intransitable, en caso contrario 0.
  • [12] surface — 1 si es superficie, en caso contrario 0.
  • [13] foliage — 1 si es follaje, en caso contrario 0.
  • [14] door — 1 si es puerta, en caso contrario 0.
  • [15] wall — 1 si es pared, en caso contrario 0.
  • [16] container — 1 si es contenedor, en caso contrario 0.

Para un graphic no válido no hay propiedades de referencia: se devuelve una matriz corta [переданный graphic, 0, ""]. Verifique la extensión completa antes de leer las propiedades. Este no es un registro de Pascal ni una lista de objetos.

Comportamiento

  • El comando lee datos de mosaicos y no requiere un elemento con ese graphic en el mundo. Las banderas describen el recurso; el resultado no reemplaza una verificación de ruta completa.

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

1. Leer nombre de entrada - guión directo

Parámetros y flujo de ejecución:

  • El mosaico es el número graphic de la tabla seleccionada.
  • data[2] contiene el nombre. La verificación de longitud separa una entrada completa de una entrada corta de un graphic no válido.
var data = UO.GetStaticTileData(0x0CCA);
if (Truth(ArrayLength(data) == 17))
{
    UO.Print(data[2]);
}
else
{
    UO.Print("Tiledata entry is unavailable");
}

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. Verificar indicador booleano individual: función de secuencia de comandos

Parámetros y flujo de ejecución:

  • data[11] es un campo separado e intransitable: 1 (condición cumplida), 0 (condición no cumplida).
  • Esta verificación no tiene en cuenta otros objetos en la celda ni las habilidades del personaje.
return  RunScenario();
 object? RunScenario()
{
    var data = UO.GetStaticTileData(0x0CCA);
    if (Truth(ArrayLength(data) == 17))
    {
        if (Truth(data[11]))
        {
            UO.Print("Impassable flag is set");
        }
        else
        {
            UO.Print("Impassable flag is not set");
        }
    }

    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. Imprimir graphic y la máscara de bandera general - clase de script

Parámetros y flujo de ejecución:

  • data[0] repite el graphic transmitido, data[1] es una máscara de bandera general.
  • La máscara puede contener varios bits al mismo tiempo; su valor numérico no es 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 data = UO.GetStaticTileData(0x0CCA);
        if (Truth(ArrayLength(data) == 17))
        {
            UO.Print("Graphic: " + Convert.ToString(data[0]));
            UO.Print("Flags: " + Convert.ToString(data[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;
}

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.GetStaticTileData(tile) — UO.GetStaticTileData(Any)

Parámetros: tile (Any)

Resultado: dynamic / Any.

Durante la llamada:

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

case "getstatictiledata":

                    return BuildTileData(1, Arg(0));

UO.GetStaticTiles

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

Firmas de C#

dynamic UO.GetStaticTiles(object? x, object? y, object? map);

Lee entradas sobre el suelo en una celda del mapa actual.

Parámetros

  • x — Celda X del mapa actualmente cargado; coordenada mundial, no posición dentro del gump.
  • y — Celda Y del mapa actualmente cargado; coordenada mundial, no posición dentro del gump.
  • map — Número de tarjeta. Si este argumento no está presente en el formulario seleccionado, se utiliza el mapa actual. El cliente real sólo lee mosaicos del mapa actualmente cargado.

Valor devuelto

La matriz es una secuencia plana de int-triples [graphic0, z0, hue0, graphic1, z1, hue1, …]. El número de entradas es igual a la longitud de la matriz / 3. Para la notación i, graphic está en [i*3], Z está en [i*3+1], hue está en [i*3+2]. Una matriz vacía significa que no hay entradas o que hay una tarjeta/celda inaccesible. Los números de serie y de capa no se devuelven aquí.

Comportamiento

  • Los datos se refieren al mapa actualmente cargado. Otra tarjeta o celda inalcanzable da como resultado una matriz vacía. Las consultas directas en mosaico también pueden informar discrepancias en los mapas; GetWorldCell y GetWorldTilesArray devuelven inmediatamente una matriz vacía sin ese mensaje.
  • Los índices de matriz comienzan con 0. Marque ArrayLength antes de leer el campo. Z representa la altitud mundial; la capa es la propiedad del equipo de Tiledata y el índice es el número de serie de la entrada de la celda.
  • El puente actual enumera elementos estáticos, múltiples y mundiales en la cadena de celdas. El nombre del comando no limita el resultado únicamente a las entradas de statics.mul. El orden de la cadena no garantiza la clasificación Z.

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

1. Contar registros de celdas: guión directo

Parámetros y flujo de ejecución:

  • x/y/map selecciona la celda actual.
  • La longitud de la matriz es el número de campos. Al dividir por 3 se obtiene el número de entradas.
var tiles = UO.GetStaticTiles(UO.GetX(), UO.GetY(), UO.WorldNum());
var count = ArrayLength(tiles) / 3;
UO.Print("Tile records: " + Convert.ToString(count));

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;

2. Recorre graphic y la altura de todas las entradas: función de script

Parámetros y flujo de ejecución:

  • offset es el índice del primer campo del siguiente triple, aumentado en 3.
  • La verificación offset+2 protege todo el registro para que no pueda leerse.
return  RunScenario();
 object? RunScenario()
{
    var tiles = UO.GetStaticTiles(UO.GetX(), UO.GetY(), UO.WorldNum());
    var offset = 0;
    while (Truth(offset + 2 < ArrayLength(tiles)))
    {
        UO.Print("Type: " + Convert.ToString(tiles[offset]) + ", Z: " + Convert.ToString(tiles[offset + 1]));
        offset = offset + 3;
    }

    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. Lea hue de la primera entrada - clase de script

Parámetros y flujo de ejecución:

  • x+1 selecciona una celda adyacente.
  • mosaicos[2] — color de la primera entrada; Esta no es la tercera ficha.
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 tiles = UO.GetStaticTiles(UO.GetX() + 1, UO.GetY(), UO.WorldNum());
        if (Truth(ArrayLength(tiles) >= 3))
        {
            var hue = tiles[2];
            UO.Print("First tile hue: " + Convert.ToString(hue));
        }
        else
        {
            UO.Print("No tile records");
        }

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

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.GetStaticTiles(x, y, map) — UO.GetStaticTiles(Any,Any,Any)

Parámetros: x (Any), y (Any), map (Any)

Resultado: dynamic / Any.

Durante la llamada:

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

public InjectionValue GetStaticTiles(InjectionValue x, InjectionValue y, InjectionValue map)

            => ToArray(bridge.GetStaticTiles(NumberConversions.ToInt(x), NumberConversions.ToInt(y), NumberConversions.ToInt(map)));

UO.GetStaticTilesArray

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

Firmas de C#

dynamic UO.GetStaticTilesArray(object? xmin, object? ymin, object? xmax, object? ymax, object? worldNum, object? tileType);

Busca entradas estáticas/multielementos/elementos por graphic/type en un rectángulo.

Parámetros

  • xmin — Coordenadas mundiales de dos ángulos, inclusive; 0...65535. Los ángulos reordenados están normalizados. Área no mayor a 1 000 000 celdas; Los límites no válidos provocan un error de secuencia de comandos antes de leer el mapa.
  • ymin — Coordenadas mundiales de dos ángulos, inclusive; 0...65535. Los ángulos reordenados están normalizados. Área no mayor a 1 000 000 celdas; Los límites no válidos provocan un error de secuencia de comandos antes de leer el mapa.
  • xmax — Coordenadas mundiales de dos ángulos, inclusive; 0...65535. Los ángulos reordenados están normalizados. Área no mayor a 1 000 000 celdas; Los límites no válidos provocan un error de secuencia de comandos antes de leer el mapa.
  • ymax — Coordenadas mundiales de dos ángulos, inclusive; 0...65535. Los ángulos reordenados están normalizados. Área no mayor a 1 000 000 celdas; Los límites no válidos provocan un error de secuencia de comandos antes de leer el mapa.
  • worldNum — Mapa/faceta 0..255; utilice UO.WorldNum(). Otro mapa muestra una matriz vacía. Si el mapa cambia entre fragmentos, el resultado parcial se descarta.
  • tileType - Un mosaico graphic/type, generalmente 0..65535; esto no es serial. 0 es exactamente graphic 0, -1 no significa ningún type. Un type que no coincide da un resultado en blanco.

Valor devuelto

Entradas de matriz [graphic, X, Y, Z, hue]; todos los campos int. graphic - type, Z - base, hue - color. Varias entradas de celda permanecen separadas. No hay coincidencias: matriz vacía. La cantidad es ArrayLength(resultado), no el resultado en sí. Los subíndices comienzan con 0. Este no es un registro bool, serial o Pascal; no hay un séptimo parámetro de salida.

Comportamiento

  • Se leen los datos locales. La búsqueda no cambia FindItem/FindCount y no realiza un movimiento, objetivo o comando de red.
  • Orden: X ascendente, dentro de X - Y ascendente. Los registros de una celda conservan el orden del puente; no está ordenado por distancia o altura.
  • La búsqueda se procesa en fragmentos de hasta 32 celdas con un presupuesto flexible de aproximadamente 1 ms. La cancelación se comprueba entre raciones. Una celda compleja o una lectura en frío pueden exceder el presupuesto. Es mejor dividir un área grande; El mundo puede cambiar mientras se lee.
  • La rama Estática del cliente actual incluye Estática, Multi y Elemento desde la celda, incluidos los elementos cargados en el suelo; Fijos y Móviles no están incluidos. Es más amplia que la selección clásica de archivos estáticos únicamente.

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.GetStaticTilesArray(UO.GetX(), UO.GetY(), UO.GetX() + 2, UO.GetY() + 2, UO.WorldNum(), 0x0CCA);
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

1. Buscar cerca de un personaje - guión directo

Parámetros y flujo de ejecución:

  • x/y - posición self, mapa - mapa actual. La región 3×3 incluye los límites. En el ejemplo se transmiten dos type, en forma normal uno. Cambie las muestras para adaptarlas a sus recursos; este es un objeto graphic, no un objeto ID.
var x = UO.GetX();
var y = UO.GetY();
var map = UO.WorldNum();
var rows = UO.GetStaticTilesArray(x, y, x + 2, y + 2, map, 0x0CCA);
UO.Print("Records: " + Convert.ToString(ArrayLength(rows)));

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;

2. Ángulos reorganizados y salida de todos los campos: función de script

Parámetros y flujo de ejecución:

  • La región 2×2 se transfiere del ángulo mayor al menor. El propio algoritmo normaliza los límites. fila - un registro; PrintTile se declara en su totalidad y solo formatea números, sin mover nada. graphic - type, x/y - coordenadas, z - altura, hue - color. Para terrenos se pasa un condicional hue=0: no hay campo de color en el registro de terrenos.
return  RunScenario();
 object? RunScenario()
{
    var x = UO.GetX();
    var y = UO.GetY();
    var map = UO.WorldNum();
    var rows = UO.GetStaticTilesArray(x + 1, y + 1, x, y, map, 0x0CCA);
    var i = 0;
    while (Truth(i < ArrayLength(rows)))
    {
        var row = rows[i];
        PrintTile(row[0], row[1], row[2], row[3], row[4]);
        i = i + 1;
    }

    return null;
}

void PrintTile(dynamic graphic, dynamic x, dynamic y, dynamic z, dynamic hue)
{
    UO.Print("Type=" + Convert.ToString(graphic) + " X=" + Convert.ToString(x) + " Y=" + Convert.ToString(y));
    UO.Print("Z=" + Convert.ToString(z) + " hue=" + Convert.ToString(hue));
}

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. Volver a sondear con límite de reintentos: clase de secuencia de comandos

Parámetros y flujo de ejecución:

  • No más de tres búsquedas por celda; entre intentos WaitAsync(250). Cada llamada crea un nuevo resultado. La longitud cero significa que no hay coincidencias ahora, en lugar de que el objeto desaparezca permanentemente 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 x = UO.GetX();
        var y = UO.GetY();
        var map = UO.WorldNum();
        var attempt = 0;
        while (Truth(attempt < 3))
        {
            var rows = UO.GetStaticTilesArray(x, y, x, y, map, 0x0CCA);
            UO.Print("Records: " + Convert.ToString(ArrayLength(rows)));
            attempt = attempt + 1;
            await Delay(250);
        }

        return null;
    }

    int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
    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.GetStaticTilesArray(xmin, ymin, xmax, ymax, worldNum, tileType) — UO.GetStaticTilesArray(Any,Any,Any,Any,Any,Any)

Parámetros: xmin (Any), ymin (Any), xmax (Any), ymax (Any), worldNum (Any), tileType (Any)

Resultado: dynamic / Any.

Durante la llamada:

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

case "getstatictilesarray":

                    return FindPortableTiles(Arg(0), Arg(1), Arg(2), Arg(3), Arg(4), new[] { Arg(5) }, true);

UO.GetStaticTilesArrayEx

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

Firmas de C#

dynamic UO.GetStaticTilesArrayEx(object? xmin, object? ymin, object? xmax, object? ymax, object? worldNum, object? tileTypes);

Busca entradas estáticas/multielementos/elementos por graphic/type en un rectángulo.

Parámetros

  • xmin — Coordenadas mundiales de dos ángulos, inclusive; 0...65535. Los ángulos reordenados están normalizados. Área no mayor a 1 000 000 celdas; Los límites no válidos provocan un error de secuencia de comandos antes de leer el mapa.
  • ymin — Coordenadas mundiales de dos ángulos, inclusive; 0...65535. Los ángulos reordenados están normalizados. Área no mayor a 1 000 000 celdas; Los límites no válidos provocan un error de secuencia de comandos antes de leer el mapa.
  • xmax — Coordenadas mundiales de dos ángulos, inclusive; 0...65535. Los ángulos reordenados están normalizados. Área no mayor a 1 000 000 celdas; Los límites no válidos provocan un error de secuencia de comandos antes de leer el mapa.
  • ymax — Coordenadas mundiales de dos ángulos, inclusive; 0...65535. Los ángulos reordenados están normalizados. Área no mayor a 1 000 000 celdas; Los límites no válidos provocan un error de secuencia de comandos antes de leer el mapa.
  • worldNum — Mapa/faceta 0..255; utilice UO.WorldNum(). Otro mapa muestra una matriz vacía. Si el mapa cambia entre fragmentos, el resultado parcial se descarta.
  • tileTypes — Matriz de números graphic/type; cada type coincidente está activado. Repetir type no duplica las entradas. El escalar también se toma como uno type. Matriz vacía lo significa todo type; una matriz de uno 0 busca solo 0.

Valor devuelto

Entradas de matriz [graphic, X, Y, Z, hue]; todos los campos int. graphic - type, Z - base, hue - color. Varias entradas de celda permanecen separadas. No hay coincidencias: matriz vacía. La cantidad es ArrayLength(resultado), no el resultado en sí. Los subíndices comienzan con 0. Este no es un registro bool, serial o Pascal; no hay un séptimo parámetro de salida.

Comportamiento

  • Se leen los datos locales. La búsqueda no cambia FindItem/FindCount y no realiza un movimiento, objetivo o comando de red.
  • Orden: X ascendente, dentro de X - Y ascendente. Los registros de una celda conservan el orden del puente; no está ordenado por distancia o altura.
  • La búsqueda se procesa en fragmentos de hasta 32 celdas con un presupuesto flexible de aproximadamente 1 ms. La cancelación se comprueba entre raciones. Una celda compleja o una lectura en frío pueden exceder el presupuesto. Es mejor dividir un área grande; El mundo puede cambiar mientras se lee.
  • La rama Estática del cliente actual incluye Estática, Multi y Elemento desde la celda, incluidos los elementos cargados en el suelo; Fijos y Móviles no están incluidos. Es más amplia que la selección clásica de archivos estáticos únicamente.

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.GetStaticTilesArrayEx(UO.X(), UO.Y(), UO.X() + 1, UO.Y() + 1, UO.WorldNum(), new[] { 0x0CCA });
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

1. Buscar cerca de un personaje - guión directo

Parámetros y flujo de ejecución:

  • x/y - posición self, mapa - mapa actual. La región 3×3 incluye los límites. En el ejemplo se transmiten dos type, en forma normal uno. Cambie las muestras para adaptarlas a sus recursos; este es un objeto graphic, no un objeto ID.
dynamic[] types = new dynamic[checked((int)(1) + 1)];
types[0] = 0x0CCA;
types[1] = 0x0CCB;
var x = UO.GetX();
var y = UO.GetY();
var map = UO.WorldNum();
var rows = UO.GetStaticTilesArrayEx(x, y, x + 2, y + 2, map, types);
UO.Print("Records: " + Convert.ToString(ArrayLength(rows)));

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;

2. Ángulos reorganizados y salida de todos los campos: función de script

Parámetros y flujo de ejecución:

  • La región 2×2 se transfiere del ángulo mayor al menor. El propio algoritmo normaliza los límites. fila - un registro; PrintTile se declara en su totalidad y solo formatea números, sin mover nada. graphic - type, x/y - coordenadas, z - altura, hue - color. Para terrenos se pasa un condicional hue=0: no hay campo de color en el registro de terrenos.
return  RunScenario();
 object? RunScenario()
{
    dynamic[] types = new dynamic[checked((int)(1) + 1)];
    types[0] = 0x0CCA;
    types[1] = 0x0CCB;
    var x = UO.GetX();
    var y = UO.GetY();
    var map = UO.WorldNum();
    var rows = UO.GetStaticTilesArrayEx(x + 1, y + 1, x, y, map, types);
    var i = 0;
    while (Truth(i < ArrayLength(rows)))
    {
        var row = rows[i];
        PrintTile(row[0], row[1], row[2], row[3], row[4]);
        i = i + 1;
    }

    return null;
}

void PrintTile(dynamic graphic, dynamic x, dynamic y, dynamic z, dynamic hue)
{
    UO.Print("Type=" + Convert.ToString(graphic) + " X=" + Convert.ToString(x) + " Y=" + Convert.ToString(y));
    UO.Print("Z=" + Convert.ToString(z) + " hue=" + Convert.ToString(hue));
}

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. Volver a sondear con límite de reintentos: clase de secuencia de comandos

Parámetros y flujo de ejecución:

  • No más de tres búsquedas por celda; entre intentos WaitAsync(250). Cada llamada crea un nuevo resultado. La longitud cero significa que no hay coincidencias ahora, en lugar de que el objeto desaparezca permanentemente 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()
    {
        dynamic[] types = new dynamic[checked((int)(1) + 1)];
        types[0] = 0x0CCA;
        types[1] = 0x0CCB;
        var x = UO.GetX();
        var y = UO.GetY();
        var map = UO.WorldNum();
        var attempt = 0;
        while (Truth(attempt < 3))
        {
            var rows = UO.GetStaticTilesArrayEx(x, y, x, y, map, types);
            UO.Print("Records: " + Convert.ToString(ArrayLength(rows)));
            attempt = attempt + 1;
            await Delay(250);
        }

        return null;
    }

    int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
    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.GetStaticTilesArrayEx(xmin, ymin, xmax, ymax, worldNum, tileTypes) — UO.GetStaticTilesArrayEx(Any,Any,Any,Any,Any,Any)

Parámetros: xmin (Any), ymin (Any), xmax (Any), ymax (Any), worldNum (Any), tileTypes (Any)

Resultado: dynamic / Any.

Durante la llamada:

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

case "getstatictilesarrayex":

                    return FindPortableTiles(Arg(0), Arg(1), Arg(2), Arg(3), Arg(4), ArrayArg(5), true);

UO.GetSurfaceZ

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

Firmas de C#

dynamic UO.GetSurfaceZ(object? x, object? y, object? worldNum);

Lee la altura promedio de la superficie del suelo en una celda.

Parámetros

  • x — Coordenada mundial X de la celda del mapa actual, no la posición en el gump.
  • y — Coordenada mundial Y de la celda del mapa actual.
  • worldNum — Número de tarjeta/faceta; utilice UO.WorldNum(). Sólo se lee la tarjeta actualmente cargada.

Valor devuelto

int: Land.AverageZ, incluida la altura negativa y 0. Si no hay ningún mapa/terreno o el mapa no coincide, se devuelve 0, por lo que este valor no distingue los datos faltantes de la altura real 0. Esto no es bool, el piso o la altura de la estática más cercana.

Comportamiento

  • El comando lee el mapa local y no activa movimiento ni objetivo. Una celda fuera del tamaño del mapa no se reemplaza por una celda en una columna adyacente.
  • La altura de Z, graphic/type, el color de hue, las banderas y la capa de equipo tienen diferentes significados. Nulo graphic o Z=0 pueden ser datos válidos; consulte el formulario de resultados.

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

1. Altura promedio bajo personaje - guión directo

Parámetros y flujo de ejecución:

  • Los tres parámetros se relacionan con la celda actual del mapa. z es una altura numérica, no el resultado del movimiento.
var x = UO.GetX();
var y = UO.GetY();
var map = UO.WorldNum();
var z = UO.GetSurfaceZ(x, y, map);
UO.Print("Average land Z: " + Convert.ToString(z));

2. Verifique la disponibilidad de terreno antes de leer: función de script

Parámetros y flujo de ejecución:

  • GetMapCell es necesario para distinguir los datos faltantes de la altura 0. El mapa aún puede cambiar entre dos llamadas.
return  RunScenario();
 object? RunScenario()
{
    var x = UO.GetX() + 1;
    var y = UO.GetY();
    var map = UO.WorldNum();
    var cell = UO.GetMapCell(x, y, map);
    if (Truth(ArrayLength(cell) == 3))
    {
        UO.Print("Average: " + Convert.ToString(UO.GetSurfaceZ(x, y, map)));
    }
    else
    {
        UO.Print("No land data");
    }

    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. Mostrar cambio en la altura promedio hacia el este: clase de escenario

Parámetros y flujo de ejecución:

  • La diferencia muestra la pendiente de la tierra. Este ejemplo no mueve nada y no calcula la ruta.
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 map = UO.WorldNum();
        var a = UO.GetMapCell(x, y, map);
        var b = UO.GetMapCell(x + 1, y, map);
        if (Truth(ArrayLength(a) == 3) && Truth(ArrayLength(b) == 3))
        {
            var difference = UO.GetSurfaceZ(x + 1, y, map) - UO.GetSurfaceZ(x, y, map);
            UO.Print("Average difference: " + Convert.ToString(difference));
        }

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

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.GetSurfaceZ(x, y, worldNum) — UO.GetSurfaceZ(Any,Any,Any)

Parámetros: x (Any), y (Any), worldNum (Any)

Resultado: dynamic / Any.

Durante la llamada:

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

case "getsurfacez":

                    return new InjectionValue(bridge.GetSurfaceZ(Arg(0), Arg(1), Arg(2)));

UO.GetTileFlags

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

Firmas de C#

dynamic UO.GetTileFlags(object? group, object? tileId);

Lee la máscara de bits de propiedad graphic de la entrada de datos de mosaico.

Parámetros

  • group - 0 - mesa de tierra; 1 — tabla de estática graphic. La implementación considera cualquier grupo no nulo como una segunda tabla; utilice 0 o 1.
  • tileId: entradas gráficas/type en mosaicos, generalmente el número entero 0…65535. Este no es el serial de un objeto o un índice de estática dentro de una celda.

Valor devuelto

int: bits bajos 32 de indicadores de datos de mosaico. El conjunto de bits más significativo da como resultado un número de signo negativo. 0 significa la ausencia de estas banderas o tileId no válido; Esto no es un signo independiente de error y no es un bool. Se pueden configurar varias propiedades al mismo tiempo.

Comportamiento

  • Este comando lee la entrada de referencia graphic; Las coordenadas mundiales no son necesarias. group=0 y group=1 seleccionan tablas diferentes incluso si tileId es el mismo.
  • La propiedad se lee de los datos graphic, no del estado actual de un elemento 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.

object? result = UO.GetTileFlags(1, 0x0CCA);
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

1. Leer propiedad de estática conocida graphic - script directo

Parámetros y flujo de ejecución:

  • group=1 selecciona datos de mosaicos estáticos; tileId=0x0CCA - graphic árbol.
  • el valor contiene el resultado descrito en la sección Devoluciones; su significado no coincide con serial.
var value = UO.GetTileFlags(1, 0x0CCA);
if (Truth((Convert.ToUInt64(value) & 0x40UL) != 0))
{
    UO.Print("Impassable flag is set");
}

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

2. Leer propiedad graphic de un elemento encontrado - función de script

Parámetros y flujo de ejecución:

  • FindType devuelve serial. GetType lo convierte en numérico graphic.
  • group=1 se usa para artículos; en tileId graphic se transmite, no el elemento.
return  RunScenario();
 object? RunScenario()
{
    var item = UO.FindType(0x0EED, -1, "backpack");
    if (Truth(item != ""))
    {
        var graphic = UO.GetType(item);
        var value = UO.GetTileFlags(1, graphic);
        UO.Print(Convert.ToString(value));
    }

    return null;
}

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

3. Leer la propiedad del terreno bajo el personaje - clase de escenario

Parámetros y flujo de ejecución:

  • Los dos primeros argumentos GetLandscapeTile son el mundo actual X/Y; el tercero es el mapa actual.
  • land[0] contiene tierras graphic. group=0 selecciona datos de mosaicos de terreno. Para GetTileLayer/GetTileHeight el terreno da 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 land = UO.GetLandscapeTile(UO.GetX(), UO.GetY(), UO.WorldNum());
        if (Truth(ArrayLength(land) >= 3))
        {
            var graphic = land[0];
            var value = UO.GetTileFlags(0, graphic);
            UO.Print(Convert.ToString(value));
        }

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

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.GetTileFlags(group, tileId) — UO.GetTileFlags(Any,Any)

Parámetros: group (Any), tileId (Any)

Resultado: dynamic / Any.

Durante la llamada:

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

public InjectionValue GetTileFlags(InjectionValue group, InjectionValue tileId)

            => new InjectionValue(unchecked((int)bridge.GetTileFlags(NumberConversions.ToInt(group), NumberConversions.ToInt(tileId))));

UO.GetTileHeight

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

Firmas de C#

int UO.GetTileHeight(object? group, object? tileId);

Lee la altura graphic de la entrada de datos del mosaico.

Parámetros

  • group - 0 - mesa de tierra; 1 — tabla de estática graphic. La implementación considera cualquier grupo no nulo como una segunda tabla; utilice 0 o 1.
  • tileId: entradas gráficas/type en mosaicos, generalmente el número entero 0…65535. Este no es el serial de un objeto o un índice de estática dentro de una celda.

Valor devuelto

int es la altura del gráfico en unidades Z de Tiledata. Este es el tamaño de altura del gráfico, no la coordenada mundial de su base Z. Para terreno, entrada faltante o altura cero, se devuelve 0. La altura por sí sola no prueba la capacidad para cruzar el país.

Comportamiento

  • Este comando lee la entrada de referencia graphic; Las coordenadas mundiales no son necesarias. group=0 y group=1 seleccionan tablas diferentes incluso si tileId es el mismo.
  • La propiedad se lee de los datos graphic, no del estado actual de un elemento 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.GetTileHeight(1, 0x0CCA);
UO.Print("GetTileHeight: " + Convert.ToString(result));

1. Leer propiedad de estática conocida graphic - script directo

Parámetros y flujo de ejecución:

  • group=1 selecciona datos de mosaicos estáticos; tileId=0x0CCA - graphic árbol.
  • el valor contiene el resultado descrito en la sección Devoluciones; su significado no coincide con serial.
var value = UO.GetTileHeight(1, 0x0CCA);
UO.Print("Tiledata height: " + Convert.ToString(value));

2. Leer propiedad graphic de un elemento encontrado - función de script

Parámetros y flujo de ejecución:

  • FindType devuelve serial. GetType lo convierte en numérico graphic.
  • group=1 se usa para artículos; en tileId graphic se transmite, no el elemento.
return  RunScenario();
 object? RunScenario()
{
    var item = UO.FindType(0x0EED, -1, "backpack");
    if (Truth(item != ""))
    {
        var graphic = UO.GetType(item);
        var value = UO.GetTileHeight(1, graphic);
        UO.Print(Convert.ToString(value));
    }

    return null;
}

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

3. Leer la propiedad del terreno bajo el personaje - clase de escenario

Parámetros y flujo de ejecución:

  • Los dos primeros argumentos GetLandscapeTile son el mundo actual X/Y; el tercero es el mapa actual.
  • land[0] contiene tierras graphic. group=0 selecciona datos de mosaicos de terreno. Para GetTileLayer/GetTileHeight el terreno da 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 land = UO.GetLandscapeTile(UO.GetX(), UO.GetY(), UO.WorldNum());
        if (Truth(ArrayLength(land) >= 3))
        {
            var graphic = land[0];
            var value = UO.GetTileHeight(0, graphic);
            UO.Print(Convert.ToString(value));
        }

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

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.GetTileHeight(group, tileId) — UO.GetTileHeight(Any,Any)

Parámetros: group (Any), tileId (Any)

Resultado: int / Integer.

Durante la llamada:

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

public int GetTileHeight(InjectionValue group, InjectionValue tileId)

        {

            int tileGroup = NumberConversions.ToInt(group);

            int[] properties = bridge.GetTileDataProperties(tileGroup, NumberConversions.ToInt(tileId)) ?? Array.Empty<int>();

            return tileGroup == 0 || properties.Length < 7 ? 0 : properties[6];

        }

UO.GetTileLayer

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

Firmas de C#

int UO.GetTileLayer(object? group, object? tileId);

Lee el número de capa de equipo de la entrada de datos del mosaico.

Parámetros

  • group - 0 - mesa de tierra; 1 — tabla de estática graphic. La implementación considera cualquier grupo no nulo como una segunda tabla; utilice 0 o 1.
  • tileId: entradas gráficas/type en mosaicos, generalmente el número entero 0…65535. Este no es el serial de un objeto o un índice de estática dentro de una celda.

Valor devuelto

int — número de la capa de equipo graphic: por ejemplo 1=Rhand, 2=Lhand, 21=Backpack. Para una capa básica, faltante o nula, se devuelve 0. Este no es el orden de la estática en una celda, ni en un piso, ni en Z.

Comportamiento

  • Este comando lee la entrada de referencia graphic; Las coordenadas mundiales no son necesarias. group=0 y group=1 seleccionan tablas diferentes incluso si tileId es el mismo.
  • La propiedad se lee de los datos graphic, no del estado actual de un elemento 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.GetTileLayer(1, 0x0CCA);
UO.Print("GetTileLayer: " + Convert.ToString(result));

1. Leer propiedad de estática conocida graphic - script directo

Parámetros y flujo de ejecución:

  • group=1 selecciona datos de mosaicos estáticos; tileId=0x0CCA - graphic árbol.
  • el valor contiene el resultado descrito en la sección Devoluciones; su significado no coincide con serial.
var value = UO.GetTileLayer(1, 0x0CCA);
if (Truth(value == 1))
{
    UO.Print("Right-hand graphic");
}

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

2. Leer propiedad graphic de un elemento encontrado - función de script

Parámetros y flujo de ejecución:

  • FindType devuelve serial. GetType lo convierte en numérico graphic.
  • group=1 se usa para artículos; en tileId graphic se transmite, no el elemento.
return  RunScenario();
 object? RunScenario()
{
    var item = UO.FindType(0x0EED, -1, "backpack");
    if (Truth(item != ""))
    {
        var graphic = UO.GetType(item);
        var value = UO.GetTileLayer(1, graphic);
        UO.Print(Convert.ToString(value));
    }

    return null;
}

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

3. Leer la propiedad del terreno bajo el personaje - clase de escenario

Parámetros y flujo de ejecución:

  • Los dos primeros argumentos GetLandscapeTile son el mundo actual X/Y; el tercero es el mapa actual.
  • land[0] contiene tierras graphic. group=0 selecciona datos de mosaicos de terreno. Para GetTileLayer/GetTileHeight el terreno da 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 land = UO.GetLandscapeTile(UO.GetX(), UO.GetY(), UO.WorldNum());
        if (Truth(ArrayLength(land) >= 3))
        {
            var graphic = land[0];
            var value = UO.GetTileLayer(0, graphic);
            UO.Print(Convert.ToString(value));
        }

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

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.GetTileLayer(group, tileId) — UO.GetTileLayer(Any,Any)

Parámetros: group (Any), tileId (Any)

Resultado: int / Integer.

Durante la llamada:

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

public int GetTileLayer(InjectionValue group, InjectionValue tileId)

        {

            int tileGroup = NumberConversions.ToInt(group);

            int[] properties = bridge.GetTileDataProperties(tileGroup, NumberConversions.ToInt(tileId)) ?? Array.Empty<int>();

            return tileGroup == 0 || properties.Length < 2 ? 0 : properties[1];

        }

UO.GetTileName

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

Firmas de C#

string UO.GetTileName(object? group, object? tileId);

Lee el nombre graphic de la entrada de datos del mosaico.

Parámetros

  • group - 0 - mesa de tierra; 1 — tabla de estática graphic. La implementación considera cualquier grupo no nulo como una segunda tabla; utilice 0 o 1.
  • tileId: entradas gráficas/type en mosaicos, generalmente el número entero 0…65535. Este no es el serial de un objeto o un índice de estática dentro de una celda.

Valor devuelto

string: nombre de los archivos de datos de mosaicos del juego. Una cadena vacía significa un nombre vacío o un tileId no válido. El nombre se toma de los recursos del juego y no se traduce automáticamente al idioma de la interfaz IDE. Este no es el nombre de un elemento específico del servidor.

Comportamiento

  • Este comando lee la entrada de referencia graphic; Las coordenadas mundiales no son necesarias. group=0 y group=1 seleccionan tablas diferentes incluso si tileId es el mismo.
  • La propiedad se lee de los datos graphic, no del estado actual de un elemento 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.GetTileName(1, 0x0CCA);
UO.Print("GetTileName: " + Convert.ToString(result));

1. Leer propiedad de estática conocida graphic - script directo

Parámetros y flujo de ejecución:

  • group=1 selecciona datos de mosaicos estáticos; tileId=0x0CCA - graphic árbol.
  • el valor contiene el resultado descrito en la sección Devoluciones; su significado no coincide con serial.
var value = UO.GetTileName(1, 0x0CCA);
if (Truth(value != ""))
{
    UO.Print(value);
}
else
{
    UO.Print("No tiledata name");
}

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

2. Leer propiedad graphic de un elemento encontrado - función de script

Parámetros y flujo de ejecución:

  • FindType devuelve serial. GetType lo convierte en numérico graphic.
  • group=1 se usa para artículos; en tileId graphic se transmite, no el elemento.
return  RunScenario();
 object? RunScenario()
{
    var item = UO.FindType(0x0EED, -1, "backpack");
    if (Truth(item != ""))
    {
        var graphic = UO.GetType(item);
        var value = UO.GetTileName(1, graphic);
        UO.Print(Convert.ToString(value));
    }

    return null;
}

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

3. Leer la propiedad del terreno bajo el personaje - clase de escenario

Parámetros y flujo de ejecución:

  • Los dos primeros argumentos GetLandscapeTile son el mundo actual X/Y; el tercero es el mapa actual.
  • land[0] contiene tierras graphic. group=0 selecciona datos de mosaicos de terreno. Para GetTileLayer/GetTileHeight el terreno da 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 land = UO.GetLandscapeTile(UO.GetX(), UO.GetY(), UO.WorldNum());
        if (Truth(ArrayLength(land) >= 3))
        {
            var graphic = land[0];
            var value = UO.GetTileName(0, graphic);
            UO.Print(Convert.ToString(value));
        }

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

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.GetTileName(group, tileId) — UO.GetTileName(Any,Any)

Parámetros: group (Any), tileId (Any)

Resultado: string / String.

Durante la llamada:

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

public string GetTileName(InjectionValue group, InjectionValue tileId)

            => bridge.GetTileDataName(NumberConversions.ToInt(group), NumberConversions.ToInt(tileId));

UO.GetTileXYM

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

Firmas de C#

dynamic UO.GetTileXYM(object? x, object? y, object? map, object? tileStart, object? tileEnd, object? uoPath);

Lee el graphic ID coincidente de la cadena de objetos de la celda de la tarjeta de juego actualmente cargada.

Parámetros

  • x — Coordenada X celdas, int.
  • y — Coordenada Y celdas, int.
  • map — Número de tarjeta; debe coincidir con World.MapIndex y World.Map debe existir.
  • tileStart — Borde gráfico inferior habilitado.
  • tileEnd: el borde superior incluido del gráfico. El rango inverso no se reorganiza y no produce coincidencias.
  • uoPath: el parámetro de compatibilidad se convierte a string, pero el puente actual no lo usa y no carga la otra carpeta de archivos UO.

Valor devuelto

Array int con quads planos [graphic,x,y,z,graphic,x,y,z,...]. El error del mapa muestra una matriz vacía y un mensaje; ninguna coincidencia también da como resultado una matriz vacía.

Comportamiento

  • Sigue World.Map.GetTile(x,y).TNext y marca tileStart<=Graphic<=tileEnd. Los tipos de objetos no se filtran por separado: es una cadena de celdas, no solo elementos estáticos.
  • El comando lee la geometría cargada del cliente. Los datos de otro mapa/faceta no se cargan. El parámetro uoPath no se utiliza para descargar archivos; el número de entradas es igual a la longitud de la matriz/4.

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

1. Todos los gráficos de la celda actual son un guión directo.

Parámetros y flujo de ejecución:

  • Cada entrada ocupa cuatro int.
var tiles = UO.GetTileXYM(UO.GetX(),UO.GetY(),UO.WorldNum(),0,65535,"");
UO.Print(Convert.ToString(ArrayLength(tiles)/4));

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;

2. Imprimir graphic y altura - función de script

Parámetros y flujo de ejecución:

  • Los índices i y i+3 corresponden a graphic yz del mismo registro.
return  RunScenario();
 object? RunScenario()
{
    var tiles = UO.GetTileXYM(UO.GetX(), UO.GetY(), UO.WorldNum(), 0, 65535, "");
    for (int i = (int)(0); i <= ArrayLength(tiles) - 1; i += (int)(4))
    {
        UO.Print(Convert.ToString(tiles[i]) + " " + Convert.ToString(tiles[i + 3]));
    }

    return null;
}

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;

3. Rango inverso: clase de secuencia de comandos

Parámetros y flujo de ejecución:

  • El rango 100..99 no contiene ningún graphic y produce una matriz vacía.
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 tiles = UO.GetTileXYM(UO.GetX(), UO.GetY(), UO.WorldNum(), 100, 99, "");
        UO.Print(Convert.ToString(ArrayLength(tiles)));
        return null;
    }

    int ArrayLength(object? value) => value is System.Array array ? array.Length : 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.GetTileXYM(x, y, map, tileStart, tileEnd, uoPath) — UO.GetTileXYM(Any,Any,Any,Any,Any,Any)

Parámetros: x (Any), y (Any), map (Any), tileStart (Any), tileEnd (Any), uoPath (Any)

Resultado: dynamic / Any.

Durante la llamada:

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

public InjectionValue GetTileXYM(InjectionValue x, InjectionValue y, InjectionValue map, InjectionValue tileStart, InjectionValue tileEnd, InjectionValue uoPath)

            => ToArray(bridge.GetTileXYM(NumberConversions.ToInt(x), NumberConversions.ToInt(y), NumberConversions.ToInt(map), NumberConversions.ToInt(tileStart), NumberConversions.ToInt(tileEnd), uoPath.ToString()));

UO.GetUserStatic

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

Firmas de C#

string UO.GetUserStatic(object? id);

Lee un registro estático de usuario guardado.

Parámetros

  • id - int ID, obtenido por AddUserStatic; no el graphic/type y no el serial del mundo.

Valor devuelto

string — registro serializado guardado; desconocido ID da una cadena vacía.

Comportamiento

  • state.UserStatics.TryGetValue devuelve la cadena sin analizarla. Notación geométrica - "graphic|x|y|z|hue|map"; Las entradas de texto antiguas pueden ser texto diferente.
  • Lee el estado local actual. No hay paquete, objetivo o actualización automática; las lecturas individuales pueden ver diferentes estados.
  • En un host de cliente normal, estos datos de estado se toman del administrador GetPersistentState y son comunes a los scripts/chat/macros del mismo mundo/perfil, y no pertenecen a un solo script. Otro proceso o un InjectionRuntimeState aparentemente separado tiene un estado diferente. Cargar/borrar un perfil puede reemplazarlo; guardados serial todavía se comparan con el mundo cargado.

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

1. Llamada directa - guión directo

Parámetros y flujo de ejecución:

  • Lee un registro estático de usuario guardado.
UO.Print(UO.GetUserStatic(1));

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

Parámetros y flujo de ejecución:

  • state.UserStatics.TryGetValue devuelve la cadena sin analizarla. Notación geométrica - "graphic|x|y|z|hue|map"; Las entradas de texto antiguas pueden ser texto diferente.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.UserStaticExists(1)))
    {
        UO.Print(UO.GetUserStatic(1));
    }

    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 records = UO.GetUserStatics();
        if (Truth(UO.GetArrayLength(records) > 0))
        {
            UO.Print(UO.GetUserStatic(records[0][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.GetUserStatic(id) — UO.GetUserStatic(Any)

Parámetros: id (Any)

Resultado: string / String.

Durante la llamada:

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

public string GetUserStatic(InjectionValue id)

            => state.UserStatics.TryGetValue(NumberConversions.ToInt(id), out string value) ? value : string.Empty;

UO.GetUserStatics

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

Firmas de C#

dynamic UO.GetUserStatics();

Lee el estado.UserStatics.

Parámetros

No hay parámetros.

Valor devuelto

Matriz de cadenas [id, serializedText], ordenadas por id. Cada identificación es int, serializedText - string; un diccionario vacío da una matriz vacía.

Comportamiento

  • Lee el estado.UserStatics. La notación geométrica se almacena como "graphic|x|y|z|hue|map"; las entradas de texto más antiguas AddUserStatic pueden tener un formato diferente. Estas son entradas de usuarios locales, no todos mapas estáticos.
  • Lee el estado local actual. No hay paquete, objetivo o actualización automática; las lecturas individuales pueden ver diferentes estados.
  • En un host de cliente normal, estos datos de estado se toman del administrador GetPersistentState y son comunes a los scripts/chat/macros del mismo mundo/perfil, y no pertenecen a un solo script. Otro proceso o un InjectionRuntimeState aparentemente separado tiene un estado diferente. Cargar/borrar un perfil puede reemplazarlo; guardados serial todavía se comparan con el mundo cargado.

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.GetUserStatics();
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 estado.UserStatics.
var records = UO.GetUserStatics();
UO.Print(UO.GetArrayLength(records));

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

Parámetros y flujo de ejecución:

  • Lee el estado.UserStatics. La notación geométrica se almacena como "graphic|x|y|z|hue|map"; las entradas de texto más antiguas AddUserStatic pueden tener un formato diferente. Estas son entradas de usuarios locales, no todos mapas estáticos.
return  RunScenario();
 object? RunScenario()
{
    var records = UO.GetUserStatics();
    if (Truth(UO.GetArrayLength(records) > 0))
    {
        UO.Print(records[0][0]);
        UO.Print(records[0][1]);
    }

    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.GetUserStatics();
        UO.Wait(500);
        var after = UO.GetUserStatics();
        UO.Print(before);
        UO.Print(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.GetUserStatics() — UO.GetUserStatics()

Parámetros: Sin parámetros.

Resultado: dynamic / Any.

Durante la llamada:

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

public InjectionValue GetUserStatics()

            => new InjectionValue(state.UserStatics.OrderBy(pair => pair.Key)

                .Select(pair => new InjectionValue(new[] { new InjectionValue(pair.Key), new InjectionValue(pair.Value) }))

                .ToArray());

UO.GetWorldCell

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

Firmas de C#

dynamic UO.GetWorldCell(object? x, object? y);
dynamic UO.GetWorldCell(object? x, object? y, object? map);

Lee registros terrestres extendidos, registros aéreos y elementos mundiales cargados en el área seleccionada.

Parámetros

  • x — Celda X del mapa actualmente cargado; coordenada mundial, no posición dentro del gump.
  • y — Celda Y del mapa actualmente cargado; coordenada mundial, no posición dentro del gump.
  • map — Número de tarjeta. Si este argumento no está presente en el formulario seleccionado, se utiliza el mapa actual. El cliente real sólo lee mosaicos del mapa actualmente cargado.

Valor devuelto

Conjunto de registros. Cada elemento result[i] tiene el siguiente formato:

Matriz de campos 11 de un registro; los índices comienzan con 0:

  • [0] kind — string: "tierra", "estático" o "object".
  • [1] serial - int: serial elemento dinámico; para tierra/estático es 0.
  • [2] graphic - int: gráficos type.
  • [3] x, [4] y - int: coordenadas mundiales de la celda.
  • [5] z - int: la altura de la base en el mundo.
  • [6] hue - int: color, cerca del suelo 0.
  • [7] flags - int: bajo 32 bits de indicadores de datos de mosaico.
  • [8] name - string: nombre de Tiledata.
  • [9] layer - int: capa de equipo de Tiledata, cerca del suelo 0; no es un índice estático.
  • [10] height - int: altura graphic desde los datos del mosaico, cerca del suelo 0; no la coordenada Z.

ArrayLength(resultado): la cantidad de registros, no la cantidad de celdas ni la cantidad de pasos de ruta. El resultado puede estar vacío. Un x/y puede tener varias entradas con diferente Z. La entrada "object" tiene serial; la entrada "estática" no tiene un serial utilizable.

Comportamiento

  • Los datos se refieren al mapa actualmente cargado. Otra tarjeta o celda inalcanzable da como resultado una matriz vacía. Las consultas directas en mosaico también pueden informar discrepancias en los mapas; GetWorldCell y GetWorldTilesArray devuelven inmediatamente una matriz vacía sin ese mensaje.
  • Los índices de matriz comienzan con 0. Marque ArrayLength antes de leer el campo. Z representa la altitud mundial; la capa es la propiedad del equipo de Tiledata y el índice es el número de serie de la entrada de la celda.
  • La parte estática usa GetStaticTiles: su selección actual también incluye Multi/Item. Un elemento mundial también puede aparecer como "object" con serial; No trate cada entrada como un elemento único.
  • GetWorldTilesArray limita la región de las celdas 1 000 000. Exceder las coordenadas fuera de 0…65535/mapa fuera de 0…255 provoca un error de comando en lugar de una matriz parcial. Para realizar votaciones frecuentes, elija un área pequeña.

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

1. Contar y enumerar registros: guión directo

Parámetros y flujo de ejecución:

  • GetWorldCell lee una celda; GetWorldTilesArray en este ejemplo lee el cuadrado 3×3 con los bordes habilitados.
  • celdas [i] es una matriz anidada. mosaico[0] - categoría, [2] - graphic, [5] - Z.
var cells = UO.GetWorldCell(UO.GetX(), UO.GetY());
var i = 0;
while (Truth(i < ArrayLength(cells)))
{
    var tile = cells[i];
    UO.Print(tile[0] + ": " + Convert.ToString(tile[2]) + ", Z=" + Convert.ToString(tile[5]));
    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. Mostrar solo entradas con el elemento serial - función de script

Parámetros y flujo de ejecución:

  • El área se selecciona por coordenadas, no por contenedor.
  • La verificación kind="object" separa los artículos en serie de tierra/estático; [1] contiene serial.
return  RunScenario();
 object? RunScenario()
{
    var cells = UO.GetWorldCell(UO.GetX(), UO.GetY());
    var i = 0;
    while (Truth(i < ArrayLength(cells)))
    {
        var tile = cells[i];
        if (Truth(tile[0] == "object"))
        {
            UO.Print("Object serial: " + Convert.ToString(tile[1]));
        }

        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. Seleccionar registros a la altura de los caracteres: clase de secuencia de comandos

Parámetros y flujo de ejecución:

  • Tile[5] y GetZ() se comparan en las mismas unidades de altura mundial.
  • Igualdad Z filtra la base, pero no significa transitabilidad ni coincidencia de todo el suelo.
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 cells = UO.GetWorldCell(UO.GetX(), UO.GetY());
        var i = 0;
        while (Truth(i < ArrayLength(cells)))
        {
            var tile = cells[i];
            if (Truth(tile[5] == UO.GetZ()))
            {
                UO.Print(tile[8]);
            }

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

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

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

Resultado: dynamic / Any.

Durante la llamada:

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

public InjectionValue GetWorldCell(InjectionValue x, InjectionValue y)

            => GetWorldCell(x, y, new InjectionValue(bridge.WorldNumber));

UO.GetWorldCell(x, y, map) — UO.GetWorldCell(Any,Any,Any)

Parámetros: x (Any), y (Any), map (Any)

Resultado: dynamic / Any.

Durante la llamada:

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

public InjectionValue GetWorldCell(InjectionValue x, InjectionValue y, InjectionValue map)

            => BuildWorldCell(NumberConversions.ToInt(x), NumberConversions.ToInt(y), NumberConversions.ToInt(map), true);

UO.GetWorldNum

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

Firmas de C#

int UO.GetWorldNum();

Lee el número de tarjeta actual del modelo del cliente.

Parámetros

No hay parámetros.

Valor devuelto

int — índice de la tarjeta actual del cliente, normalmente 0=Felucca, 1=Trammel, 2=Ilshenar, 3=Malas, 4=Tokuno, 5=Ter Mur. El servidor de usuario puede utilizar un juego de tarjetas diferente. 0 es un mapa completo, no una señal de error.

Comportamiento

  • Se leen los datos locales ya recibidos. La solicitud no abre el estado y no obliga al servidor a enviar una actualización. Después de la muerte, la transición del mapa o la eliminación de un objeto, los valores pueden cambiar entre dos llamadas.
  • C# distingue mayúsculas y minúsculas. Use el nombre UO exacto. Compare indicadores numéricos con 0; use bool solo si la firma devuelve bool.

Scripts independientes de C#

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

Ejemplo sencillo

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

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

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

1. Muestra el valor actual de tu personaje - script directo

Parámetros y flujo de ejecución:

  • La llamada sin argumentos hace referencia a self. El número de tarjeta actual se almacena en valor.
  • Convertir.ToString convierte el número que se generará y no cambia el significado del resultado.
var value = UO.GetWorldNum();
UO.Print("GetWorldNum: " + Convert.ToString(value));

2. Usar valor en la validación de la aplicación: función de secuencia de comandos

Parámetros y flujo de ejecución:

  • El valor se lee una vez sin ningún argumento. El número de tarjeta actual se utiliza en el cálculo o condición que se muestra.
  • Los umbrales numéricos son ejemplos de condiciones de script y no de límites de nuevos clientes. El campo almacena las unidades de servidor y las restricciones descritas anteriormente.
return  RunScenario();
 object? RunScenario()
{
    var value = UO.GetWorldNum();
    var land = UO.GetLandscapeTile(UO.GetX(), UO.GetY(), value);
    UO.Print("Land record length: " + Convert.ToString(ArrayLength(land)));
    return null;
}

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;

3. Mira el cambio en un segundo - clase de guión

Parámetros y flujo de ejecución:

  • Ambas llamadas sin argumento leen su valor actual. UO.Wait(1000) da una pausa de milisegundos entre disparos.
  • El cambio comparado es el número de la tarjeta actual. Un ejemplo no cambia nada en el mundo y no espera sin cesar. Es posible que se pierdan los eventos ocurridos dentro de este segundo.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

    async public Task<object?> RunScenarioAsync()
    {
        var before = UO.GetWorldNum();
        await Delay(1000);
        var after = UO.GetWorldNum();
        if (Truth(before != after))
        {
            UO.Print("Before: " + Convert.ToString(before) + "; after: " + Convert.ToString(after));
        }

        return null;
    }

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

Implementación del comando

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

UO.GetWorldNum() — UO.GetWorldNum()

Parámetros: Sin parámetros.

Resultado: int / Integer.

Durante la llamada:

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

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

() => bridge.WorldNumber

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

UO.GetWorldTilesArray

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

Firmas de C#

dynamic UO.GetWorldTilesArray(object? minX, object? minY, object? maxX, object? maxY, object? map);

Lee registros terrestres extendidos, registros aéreos y elementos mundiales cargados en el área seleccionada.

Parámetros

  • minX — El primer borde X del rectángulo, incluido; 0…65535.
  • minY — El primer borde Y del rectángulo, incluido; 0…65535.
  • maxX — Segundo límite incluido X; la menor/mayor de las dos X se selecciona automáticamente.
  • maxY — Segundo límite incluido Y; la menor/mayor de las dos Y se selecciona automáticamente.
  • map — Número de tarjeta. Si este argumento no está presente en el formulario seleccionado, se utiliza el mapa actual. El cliente real sólo lee mosaicos del mapa actualmente cargado.

Valor devuelto

Conjunto de registros. Cada elemento result[i] tiene el siguiente formato:

Matriz de campos 11 de un registro; los índices comienzan con 0:

  • [0] kind — string: "tierra", "estático" o "object".
  • [1] serial - int: serial elemento dinámico; para tierra/estático es 0.
  • [2] graphic - int: gráficos type.
  • [3] x, [4] y - int: coordenadas mundiales de la celda.
  • [5] z - int: la altura de la base en el mundo.
  • [6] hue - int: color, cerca del suelo 0.
  • [7] flags - int: bajo 32 bits de indicadores de datos de mosaico.
  • [8] name - string: nombre de Tiledata.
  • [9] layer - int: capa de equipo de Tiledata, cerca del suelo 0; no es un índice estático.
  • [10] height - int: altura graphic desde los datos del mosaico, cerca del suelo 0; no la coordenada Z.

ArrayLength(resultado): la cantidad de registros, no la cantidad de celdas ni la cantidad de pasos de ruta. El resultado puede estar vacío. Un x/y puede tener varias entradas con diferente Z. La entrada "object" tiene serial; la entrada "estática" no tiene un serial utilizable.

Comportamiento

  • Los datos se refieren al mapa actualmente cargado. Otra tarjeta o celda inalcanzable da como resultado una matriz vacía. Las consultas directas en mosaico también pueden informar discrepancias en los mapas; GetWorldCell y GetWorldTilesArray devuelven inmediatamente una matriz vacía sin ese mensaje.
  • Los índices de matriz comienzan con 0. Marque ArrayLength antes de leer el campo. Z representa la altitud mundial; la capa es la propiedad del equipo de Tiledata y el índice es el número de serie de la entrada de la celda.
  • La parte estática usa GetStaticTiles: su selección actual también incluye Multi/Item. Un elemento mundial también puede aparecer como "object" con serial; No trate cada entrada como un elemento único.
  • GetWorldTilesArray limita la región de las celdas 1 000 000. Exceder las coordenadas fuera de 0…65535/mapa fuera de 0…255 provoca un error de comando en lugar de una matriz parcial. Para realizar votaciones frecuentes, elija un área pequeña.

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

1. Contar y enumerar registros: guión directo

Parámetros y flujo de ejecución:

  • GetWorldCell lee una celda; GetWorldTilesArray en este ejemplo lee el cuadrado 3×3 con los bordes habilitados.
  • celdas [i] es una matriz anidada. mosaico[0] - categoría, [2] - graphic, [5] - Z.
var cells = UO.GetWorldTilesArray(UO.GetX() - 1, UO.GetY() - 1, UO.GetX() + 1, UO.GetY() + 1, UO.WorldNum());
var i = 0;
while (Truth(i < ArrayLength(cells)))
{
    var tile = cells[i];
    UO.Print(tile[0] + ": " + Convert.ToString(tile[2]) + ", Z=" + Convert.ToString(tile[5]));
    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. Mostrar solo entradas con el elemento serial - función de script

Parámetros y flujo de ejecución:

  • El área se selecciona por coordenadas, no por contenedor.
  • La verificación kind="object" separa los artículos en serie de tierra/estático; [1] contiene serial.
return  RunScenario();
 object? RunScenario()
{
    var cells = UO.GetWorldTilesArray(UO.GetX() - 1, UO.GetY() - 1, UO.GetX() + 1, UO.GetY() + 1, UO.WorldNum());
    var i = 0;
    while (Truth(i < ArrayLength(cells)))
    {
        var tile = cells[i];
        if (Truth(tile[0] == "object"))
        {
            UO.Print("Object serial: " + Convert.ToString(tile[1]));
        }

        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. Seleccionar registros a la altura de los caracteres: clase de secuencia de comandos

Parámetros y flujo de ejecución:

  • Tile[5] y GetZ() se comparan en las mismas unidades de altura mundial.
  • Igualdad Z filtra la base, pero no significa transitabilidad ni coincidencia de todo el suelo.
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 cells = UO.GetWorldTilesArray(UO.GetX() - 1, UO.GetY() - 1, UO.GetX() + 1, UO.GetY() + 1, UO.WorldNum());
        var i = 0;
        while (Truth(i < ArrayLength(cells)))
        {
            var tile = cells[i];
            if (Truth(tile[5] == UO.GetZ()))
            {
                UO.Print(tile[8]);
            }

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

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.GetWorldTilesArray(minX, minY, maxX, maxY, map) — UO.GetWorldTilesArray(Any,Any,Any,Any,Any)

Parámetros: minX (Any), minY (Any), maxX (Any), maxY (Any), map (Any)

Resultado: dynamic / Any.

Durante la llamada:

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

public InjectionValue GetWorldTilesArray(InjectionValue minX, InjectionValue minY, InjectionValue maxX, InjectionValue maxY, InjectionValue map)

        {

            int firstX = Math.Min(NumberConversions.ToInt(minX), NumberConversions.ToInt(maxX));

            int lastX = Math.Max(NumberConversions.ToInt(minX), NumberConversions.ToInt(maxX));

            int firstY = Math.Min(NumberConversions.ToInt(minY), NumberConversions.ToInt(maxY));

            int lastY = Math.Max(NumberConversions.ToInt(minY), NumberConversions.ToInt(maxY));

            int world = NumberConversions.ToInt(map);

            if (firstX < 0 || firstY < 0 || lastX > ushort.MaxValue || lastY > ushort.MaxValue

                || world < 0 || world > byte.MaxValue)

                throw new NativeSubrutineException("World tile coordinates must be 0..65535 and the map must be 0..255.");

            if (((long)lastX - firstX + 1) * ((long)lastY - firstY + 1) > 1_000_000L)

                throw new NativeSubrutineException("World tile array is limited to 1,000,000 cells per call.");

            // Live world items have no per-result map field. Never combine the

            // current world's items with a request for a different map, or scan

            // every cell only to report the same unloaded-map failure repeatedly.

            if (world != bridge.WorldNumber)

                return new InjectionValue(Array.Empty<InjectionValue>());



            var result = new List<InjectionValue>();

            for (int cellX = firstX; cellX <= lastX; cellX++)

            for (int cellY = firstY; cellY <= lastY; cellY++)

            {

                InjectionValue cell = BuildWorldCell(cellX, cellY, world, false);

                if (cell.Kind == InjectionValueKind.Array)

                    result.AddRange(cell.Array);

            }



            foreach (int serial in bridge.GetWorldItems() ?? Array.Empty<int>())

            {

                int objectX = bridge.GetX(serial);

                int objectY = bridge.GetY(serial);

                if (objectX >= firstX && objectX <= lastX && objectY >= firstY && objectY <= lastY)

                    result.Add(BuildWorldTileRecord("object", serial, bridge.GetGraphics(serial), objectX, objectY,

                        bridge.GetZ(serial), bridge.GetColor(serial), 1));

            }

            return new InjectionValue(result.ToArray());

        }

UO.GetX

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

Firmas de C#

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

Lee el campo X del objeto cargado o carácter actual.

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

int es la coordenada X. Para un objeto desconocido, se devuelve 0. El cero también es una coordenada válida. Medido en celdas para objetos del mundo; Estos no son píxeles de la pantalla.

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.
  • Para un personaje u objeto en tierra, esta es la coordenada mundial. El artículo dentro del contenedor tiene una posición X/Y dentro del chicle; el comando no los traduce a las coordenadas mundiales del propietario.
  • Se lee la coordenada actual del objeto. Los pasos en espera de confirmación no se convierten en cálculos de ruta mediante este comando.

Ejemplo .csx

int x = UO.GetX();
UO.Print($"X = {x}");

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

1. Lea su coordenada - guión directo

Parámetros y flujo de ejecución:

  • El formulario sin argumento selecciona self, el carácter actual.
  • La posición contiene la coordenada X, no serial.
var position = UO.GetX();
UO.Print("X: " + Convert.ToString(position));

2. Comparar con el carácter seleccionado - función de script

Parámetros y flujo de ejecución:

  • lasttarget debe apuntar al personaje o elemento cargado en el suelo.
  • delta: diferencia a lo largo de un eje. No es la longitud del recorrido; el valor puede ser negativo.
return  RunScenario();
 object? RunScenario()
{
    var other = UO.GetSerial("lasttarget");
    if (Truth(UO.Exists(other)))
    {
        var delta = UO.GetX(other) - UO.GetX();
        UO.Print("Difference: " + Convert.ToString(delta));
    }

    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. Recuerde señalar y comparar más tarde - clase de script

Parámetros y flujo de ejecución:

  • id="self" es una forma explícita de selección de caracteres. UO.Wait=500 milisegundos.
  • La comparación muestra el cambio únicamente en el eje X. Aquí no se tienen en cuenta los cambios en el otro eje ni la rotación.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

    async public Task<object?> RunScenarioAsync()
    {
        var before = UO.GetX("self");
        await Delay(500);
        var after = UO.GetX("self");
        if (Truth(before != after))
        {
            UO.Print("Coordinate changed");
        }

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

Parámetros: Sin parámetros.

Resultado: int / Integer.

Durante la llamada:

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

public int GetX() => GetX("self");

UO.GetX(id) — UO.GetX(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 "getx": return new InjectionValue(bridge.GetX(Arg(0, bridge.Self)));

UO.GetX(id) — UO.GetX(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 GetX(int id) => bridge.GetX(id);

UO.GetX(id) — UO.GetX(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 GetX(string id) => GetX(GetObject(id));

UO.GetY

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

Firmas de C#

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

Lee el campo Y del objeto cargado o carácter actual.

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

int es la coordenada Y. Para un objeto desconocido, se devuelve 0. El cero también es una coordenada válida. Medido en celdas para objetos del mundo; Estos no son píxeles de la pantalla.

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.
  • Para un personaje u objeto en tierra, esta es la coordenada mundial. El artículo dentro del contenedor tiene una posición X/Y dentro del chicle; el comando no los traduce a las coordenadas mundiales del propietario.
  • Se lee la coordenada actual del objeto. Los pasos en espera de confirmación no se convierten en cálculos de ruta mediante este comando.

Ejemplo .csx

int y = UO.GetY();
UO.Print($"Y = {y}");

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

1. Lea su coordenada - guión directo

Parámetros y flujo de ejecución:

  • El formulario sin argumento selecciona self, el carácter actual.
  • La posición contiene la coordenada Y, no serial.
var position = UO.GetY();
UO.Print("Y: " + Convert.ToString(position));

2. Comparar con el carácter seleccionado - función de script

Parámetros y flujo de ejecución:

  • lasttarget debe apuntar al personaje o elemento cargado en el suelo.
  • delta: diferencia a lo largo de un eje. No es la longitud del recorrido; el valor puede ser negativo.
return  RunScenario();
 object? RunScenario()
{
    var other = UO.GetSerial("lasttarget");
    if (Truth(UO.Exists(other)))
    {
        var delta = UO.GetY(other) - UO.GetY();
        UO.Print("Difference: " + Convert.ToString(delta));
    }

    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. Recuerde señalar y comparar más tarde - clase de script

Parámetros y flujo de ejecución:

  • id="self" es una forma explícita de selección de caracteres. UO.Wait=500 milisegundos.
  • La comparación muestra el cambio únicamente en el eje Y. Aquí no se tienen en cuenta los cambios en el otro eje ni la rotación.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

    async public Task<object?> RunScenarioAsync()
    {
        var before = UO.GetY("self");
        await Delay(500);
        var after = UO.GetY("self");
        if (Truth(before != after))
        {
            UO.Print("Coordinate changed");
        }

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

Parámetros: Sin parámetros.

Resultado: int / Integer.

Durante la llamada:

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

public int GetY() => GetY("self");

UO.GetY(id) — UO.GetY(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 "gety": return new InjectionValue(bridge.GetY(Arg(0, bridge.Self)));

UO.GetY(id) — UO.GetY(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 GetY(int id) => bridge.GetY(id);

UO.GetY(id) — UO.GetY(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 GetY(string id) => GetY(GetObject(id));

ClassicUO — Bad Newbie & C# Scripts IDE

ClassicUO — Bad Newbie & C# Scripts IDE

Clone this wiki locally