Repository navigation
ES UO Topic movement
Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
Inicio · C# · IDE · UO API · A–Z · Ejemplos · Idiomas
Movimiento de personajes, construcción de caminos, puertas, obstáculos y retrasos de pasos. Los comandos para mover cosas se encuentran en Elementos → Moving Elementos.
UO.Move · UO.MoveXY · UO.MoveXYZ · UO.NewMoveXY · UO.Step · UO.StepQ · UO.PMove · UO.MoveOn · UO.MoveOff · UO.MoverStop · UO.CancelMove · UO.Moving · UO.IsMoving · UO.GetRun · UO.IsRunning · UO.AlwaysRun · UO.FixWalk
UO.Dir · UO.Direction · UO.GetDir · UO.GetDirection · UO.CalcDir · UO.PredictedDirection
UO.GetPathArray · UO.GetPathArray3D · UO.AddStep · UO.AddDir
UO.OpenDoor · UO.LastStepQUsedDoor
UO.moveBetweenTwoCorners · UO.moveCheckStamina · UO.moveExitOnDisconnect · UO.moveHeuristicMult · UO.moveOpenDoor · UO.moveThroughCorner · UO.moveThroughNPC · UO.moveTurnCost
UO.PredictedX · UO.PredictedY · UO.PredictedZ
UO.GetRunMountTimer · UO.GetRunUnMountTimer · UO.GetWalkMountTimer · UO.GetWalkUnmountTimer · UO.SetRunMountTimer · UO.SetRunUnmountTimer · UO.SetWalkMountTimer · UO.SetWalkUnmountTimer
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.
Parámetros, resultado y todos los escenarios
var x = UO.GetX() + 3;
var y = UO.GetY();
var ok = UO.NewMoveXY(x, y, true, 0, false);
if (Truth(ok))
{
UO.Print("Destination reached");
}
else
{
UO.Print("Destination not reached");
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parámetros, resultado y todos los escenarios
var x = UO.GetX();
var y = UO.GetY();
var z = UO.GetZ();
var path = UO.GetPathArray3D(x, y, z, x + 4, y, z, UO.WorldNum(), 0, 0, false);
if (Truth(ArrayLength(path) > 0))
{
UO.Print("Steps: " + Convert.ToString(ArrayLength(path) - 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;Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.AddDir(object? arg0);-
directionses una cadena guardada en la lista heredada. El significado y el formato del valor dependen del script compatible que lo utilice.
void. El asiento añadido no es confirmación del movimiento.
- El valor se agrega a la lista
AddDirdel estado de ejecución actual. La llamada en sí no pasa un paquete de movimiento, no mueve el personaje y no tiene un captador público documentado para leer esta lista.
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.
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.AddDir");
UO.AddDir("E");1. Guarde la dirección como una entrada compatible con legado sin mover el personaje. - guión directo
Parámetros y flujo de ejecución:
- Guarde la dirección como una entrada compatible con legado sin mover el personaje.
UO.AddDir("E");Parámetros y flujo de ejecución:
- Pase el valor de la variable a la lista heredada AddDir.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var directionEntry = "north-east";
UO.AddDir(directionEntry);
return null;
}Parámetros y flujo de ejecución:
- Cada llamada agrega otra entrada de cadena al estado de ejecución.
- El procedimiento auxiliar tampoco envía un comando de movimiento.
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()
{
AddLegacyDirection("W");
return null;
}
void AddLegacyDirection(dynamic entry)
{
UO.AddDir(entry);
}
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.AddStep(object? arg0);-
directionses el valor que el tiempo de ejecución convierte en texto y agrega a la lista de compatibilidadAddStep. La dirección en sí no es interpretable.
void. La llamada no devuelve un valor y no confirma el movimiento.
- Cada llamada agrega una representación de cadena del argumento a la lista
AddStepdel estado de ejecución actual. Esta entrada heredada no envía un comando de movimiento y no tiene un captador público en la implementación actual.
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.
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.AddStep");
UO.AddStep(2);Parámetros y flujo de ejecución:
- Escriba el valor en la lista heredada; el personaje no se mueve.
UO.AddStep(2);2. Pasar valor de texto: se almacena como un registro en lugar de ejecutarse como una dirección. - función de guión
Parámetros y flujo de ejecución:
- Pasar valor de texto: se almacena como un registro en lugar de ejecutarse como una dirección.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var legacyValue = "east";
UO.AddStep(legacyValue);
return null;
}3. Cada llamada agrega una entrada separada a AddStep del tiempo de ejecución actual. - clase de guión
Parámetros y flujo de ejecución:
- Cada llamada agrega una entrada separada a AddStep del tiempo de ejecución actual.
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()
{
UO.AddStep(1);
UO.AddStep(2);
return null;
}
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.AlwaysRun();
void UO.AlwaysRun(object? arg0);Lee o cambia la configuración de ejecución constante del perfil ClassicUO actual.
-
enabled-0desactiva la ejecución constante; cualquier valor distinto de cero lo activa.
El formulario sin argumentos devuelve 1 si la configuración está habilitada, 0 en caso contrario. La forma del argumento devuelve null.
- El valor se lee del perfil actual. La configuración cambia
AlwaysRuny guarda el perfil actual. Sin un perfil activo, el captador devuelve0y el configurador informa un error en el registro del cliente y no cambia la configuración.
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.
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.AlwaysRun();
UO.Print("AlwaysRun: " + Convert.ToString(result));Parámetros y flujo de ejecución:
- Lea la configuración; 1 significa que la ejecución constante está habilitada.
var isAlwaysRunning = UO.AlwaysRun();
UO.Print(Convert.ToString(isAlwaysRunning));Parámetros y flujo de ejecución:
- Habilite la ejecución constante y guarde la configuración del perfil actual.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
UO.AlwaysRun(1);
return null;
}Parámetros y flujo de ejecución:
- Deshabilite la ejecución constante solo si está actualmente habilitada.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
if (Truth(UO.AlwaysRun() != 0))
{
UO.AlwaysRun(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;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.CalcDir(object? arg0, object? arg1, object? arg2, object? arg3);Calcula la dirección de un punto del mundo a otro. El personaje no se mueve.
-
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.
int - código de dirección: 0=norte, 1=noreste, 2=este, 3=sureste, 4=sur, 5=suroeste, 6=oeste, 7=noroeste. Los puntos coincidentes dan 100. Esto no es un bool: 0 significa norte, no fracaso; 1 significa noreste, no éxito. No pase 100 al comando de paso como dirección.
- 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.
- Las coordenadas originales se restan de las coordenadas de destino y luego se verifican los signos de las diferencias. Y decreciente es el norte, X creciente es el este. Si ambas coordenadas cambian, se elige la diagonal independientemente de la magnitud de las diferencias. Si ambas diferencias son cero - 100.
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.
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.CalcDir(100, 100, 101, 100);
UO.Print("CalcDir: " + Convert.ToString(result));Parámetros y flujo de ejecución:
- Origen (100,100), destino (101,100): X aumenta, Y no cambia. Retornos principales int 2 - este. El comando de movimiento no se llama.
- int - código de dirección: 0=norte, 1=noreste, 2=este, 3=sureste, 4=sur, 5=suroeste, 6=oeste, 7=noroeste. Los puntos coincidentes dan 100. Esto no es un bool: 0 significa norte, no fracaso; 1 significa noreste, no éxito. No pase 100 al comando de paso como dirección.
- Las coordenadas originales se restan de las coordenadas de destino y luego se verifican los signos de las diferencias. Y decreciente es el norte, X creciente es el este. Si ambas coordenadas cambian, se elige la diagonal independientemente de la magnitud de las diferencias. Si ambas diferencias son cero - 100.
return UO.CalcDir(100,100,101,100);Parámetros y flujo de ejecución:
- Ambos puntos son iguales (100,100). dirección=100 significa una coincidencia, por lo que Main devuelve string "ya está allí". En diferentes puntos funcionará otra sucursal. Es 100 el que está marcado, no true.
- int - código de dirección: 0=norte, 1=noreste, 2=este, 3=sureste, 4=sur, 5=suroeste, 6=oeste, 7=noroeste. Los puntos coincidentes dan 100. Esto no es un bool: 0 significa norte, no fracaso; 1 significa noreste, no éxito. No pase 100 al comando de paso como dirección.
- Las coordenadas originales se restan de las coordenadas de destino y luego se verifican los signos de las diferencias. Y decreciente es el norte, X creciente es el este. Si ambas coordenadas cambian, se elige la diagonal independientemente de la magnitud de las diferencias. Si ambas diferencias son cero - 100.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var direction = UO.CalcDir(100, 100, 100, 100);
if (Truth(direction == 100))
{
return "already there";
}
return "different point";
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parámetros y flujo de ejecución:
- Al pasar de (20,20) a (19,21), X disminuye, Y aumenta: UO.CalcDir devuelve 5. RebuildDirection muestra todas las ramas de este algoritmo y también proporciona 5. Principal devuelve "5:5". Los cuatro parámetros del asistente tienen el mismo significado de coordenadas.
- int - código de dirección: 0=norte, 1=noreste, 2=este, 3=sureste, 4=sur, 5=suroeste, 6=oeste, 7=noroeste. Los puntos coincidentes dan 100. Esto no es un bool: 0 significa norte, no fracaso; 1 significa noreste, no éxito. No pase 100 al comando de paso como dirección.
- Las coordenadas originales se restan de las coordenadas de destino y luego se verifican los signos de las diferencias. Y decreciente es el norte, X creciente es el este. Si ambas coordenadas cambian, se elige la diagonal independientemente de la magnitud de las diferencias. Si ambas diferencias son cero - 100.
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 actual = UO.CalcDir(20, 20, 19, 21);
var rebuilt = RebuildDirection(20, 20, 19, 21);
return Convert.ToString(actual) + ":" + Convert.ToString(rebuilt);
return null;
}
dynamic RebuildDirection(dynamic Xfrom, dynamic Yfrom, dynamic Xto, dynamic Yto)
{
var dx = Xto - Xfrom;
var dy = Yto - Yfrom;
if (Truth(dx == 0) && Truth(dy == 0))
{
return 100;
}
if (Truth(dx == 0))
{
if (Truth(dy < 0))
{
return 0;
}
return 4;
}
if (Truth(dy == 0))
{
if (Truth(dx > 0))
{
return 2;
}
return 6;
}
if (Truth(dx > 0))
{
if (Truth(dy < 0))
{
return 1;
}
return 3;
}
if (Truth(dy > 0))
{
return 5;
}
return 7;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.CancelMove();Desactiva permitir un mayor movimiento por parte del script a través de MoveOff.
No hay parámetros.
void: sin valor de retorno.
- Llama a MoveOff, lo que coloca el tiempo de ejecución/administrador en el estado MoveEnabled=false. Para permitir el movimiento nuevamente, se necesita MoveOn. El comando no revierte los pasos que ya se han enviado.
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.
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.CancelMove");
UO.CancelMove();Parámetros y flujo de ejecución:
- Los siguientes comandos de movimiento respetan la resolución que se desactiva.
UO.CancelMove();Parámetros y flujo de ejecución:
- MoveOn restaura explícitamente la resolución.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
UO.CancelMove();
UO.MoveOn();
return null;
}Parámetros y flujo de ejecución:
- Una conexión desconectada se utiliza como condición para prohibir pasos posteriores.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
if (!(Truth(UO.Connected())))
{
UO.CancelMove();
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.Dir();Lee la dirección del carácter del modelo del cliente.
No hay parámetros.
int — dirección mobile sin bit en marcha: 0=N, 1=NE, 2=E, 3=SE, 4=S, 5=SW, 6=W, 7=NW. Para desconocido, mobile devuelve 0, que también significa norte.
- 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.
- Estas son funciones de lectura: al asignar el resultado a una variable se guarda la instantánea. No cambia las características del personaje. Los nombres no distinguen entre mayúsculas y minúsculas; utilice exactamente el formulario que se muestra con el número requerido de argumentos.
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.
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.Dir();
UO.Print("Dir: " + Convert.ToString(result));Parámetros y flujo de ejecución:
- La llamada sin argumentos hace referencia a self. La dirección del personaje se almacena en valor.
- Convertir.ToString convierte el número que se generará y no cambia el significado del resultado.
var value = UO.Dir();
UO.Print("Dir: " + Convert.ToString(value));Parámetros y flujo de ejecución:
- El valor se lee una vez sin ningún argumento. La dirección del personaje 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 await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var value = UO.Dir();
if (Truth(value == 2))
{
UO.Print("Facing east");
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;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.
- Cambio comparado: dirección del personaje. 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.Dir();
await Delay(1000);
var after = UO.Dir();
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;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.Direction();Lee la dirección del carácter del modelo del cliente.
No hay parámetros.
int — dirección mobile sin bit en marcha: 0=N, 1=NE, 2=E, 3=SE, 4=S, 5=SW, 6=W, 7=NW. Para desconocido, mobile devuelve 0, que también significa norte.
- 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.
- Estas son funciones de lectura: al asignar el resultado a una variable se guarda la instantánea. No cambia las características del personaje. Los nombres no distinguen entre mayúsculas y minúsculas; utilice exactamente el formulario que se muestra con el número requerido de argumentos.
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.
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.Direction();
UO.Print("Direction: " + Convert.ToString(result));Parámetros y flujo de ejecución:
- La llamada sin argumentos hace referencia a self. La dirección del personaje se almacena en valor.
- Convertir.ToString convierte el número que se generará y no cambia el significado del resultado.
var value = UO.Direction();
UO.Print("Direction: " + Convert.ToString(value));Parámetros y flujo de ejecución:
- El valor se lee una vez sin ningún argumento. La dirección del personaje 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 await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var value = UO.Direction();
if (Truth(value == 2))
{
UO.Print("Facing east");
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;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.
- Cambio comparado: dirección del personaje. 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.Direction();
await Delay(1000);
var after = UO.Direction();
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;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.FixWalk();Imprime un aviso de que ClassicUO no requiere el parche de cliente nativo heredado FixWalk.
No hay parámetros.
void: sin valor de retorno.
- La rama ExecuteLegacyManualAlias solo llama a SystemMessage. No corrige el movimiento, la voz, los contenedores ni el protocolo de red.
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.
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.FixWalk");
UO.FixWalk();Parámetros y flujo de ejecución:
- El mensaje describe la falta de necesidad del parche antiguo.
UO.FixWalk();Parámetros y flujo de ejecución:
- El procedimiento de compatibilidad no cambia el mundo del juego.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
CompatibilityNotice();
return null;
}
void CompatibilityNotice()
{
UO.FixWalk();
}Parámetros y flujo de ejecución:
- Después del mensaje de diagnóstico, la ejecución continúa.
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()
{
UO.FixWalk();
UO.Print("continued");
return null;
}
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.Follow();
int UO.Follow(object? arg0);
int UO.Follow(object? arg0, object? arg1);
int UO.Follow(object? arg0, object? arg1, object? arg2);
int UO.Follow(object? arg0, object? arg1, object? arg2, object? arg3);
int UO.Follow(object? arg0, object? arg1, object? arg2, object? arg3, object? arg4);
int UO.Follow(object? arg0, object? arg1, object? arg2, object? arg3, object? arg4, object? arg5);Habilita el seguimiento en segundo plano del carácter cargado/NPC o el movimiento al punto X, Y, Z. Durante el movimiento, el cliente verifica las condiciones de parada transmitidas; el script continúa su ejecución inmediatamente después de la llamada.
-
target— Serie de caracteres/NPC: int, cadena hexadecimal/decimal, lasttarget o nombre guardado previamente mediante AddObject. Estos no son graphic/type ni coordenadas. No puedes seguirte a ti mismo ni a un objeto. 0 deja de seguir. Sin argumentos, Follow() también lo detiene; la vista no aparece. -
distance— Tolerancia X/Y en celdas: máxima |dx| y |dy|. Para el carácter int 1..18, el valor predeterminado es 1; La diferencia Z hasta 16 es aceptable. Para el punto int 0..18, se requiere el argumento: 0 requiere X/Y exacto, 2 permite detenerse dentro de dos celdas; Z debe coincidir exactamente. Un valor no válido no reemplaza el comportamiento anterior. -
running- valor compatible con bool: true/1 - correr, false/0 - caminar; el valor predeterminado es true. Los límites de velocidad del servidor, la resistencia, la parálisis y los obstáculos persisten. La bandera no acelera los pasos del servidor. -
stopConditions— Matriz opcional de condiciones de detención: cuarto argumento para carácter, sexto para coordenadas. Cada elemento es una matriz de exactamente tres valores [campo, comparación, umbral]. el campo y la comparación son cadenas, el umbral es int/double; para banderas true/false (1/0) son adecuadas. La activación de CUALQUIER condición finaliza Follow (OR). Una matriz vacía no agrega condiciones. El número de elementos no se limita a elementos fijos 3/5/10, sino que está limitado por la memoria; Las listas grandes se revisan en partes. Los campos y unidades permitidos se enumeran a continuación; un campo desconocido, un operador o un formulario de matriz no válido provoca un error antes de que se reemplace el antiguo Follow. -
x: solo formularios con argumentos 5/6: coordenadas mundiales enteras en el mapa actual, 0..65535 y dentro de los límites del mapa cargado. Estas no son coordenadas de ventana/gump o serial. No hay transferencia a otra tarjeta. -
y: solo formularios con argumentos 5/6: coordenadas mundiales enteras en el mapa actual, 0..65535 y dentro de los límites del mapa cargado. Estas no son coordenadas de ventana/gump o serial. No hay transferencia a otra tarjeta. -
z: solo formularios con argumentos 5/6: altura mundial entera -128..127. Esta altura es necesaria para la finalización, así que especifique la Z de la superficie disponible del piso deseado. No hay valores separados de "cualquier Z" ni selección automática de altura.
int 1 (true): el cliente ha aceptado el siguiente modo o se ha completado una solicitud de detención; int 0 (false): no hay ningún personaje adecuado cargado, el jugador no está disponible/muerto, el objetivo está fuera de la vista, la distancia es incorrecta o el cliente no apoya al equipo. Este no es el resultado de la llegada, ni serial, ni el número de pasos. En C# use if (resultado!= 0) o if (resultado == 1); El resultado es del tipo int, no bool. Los errores de tipo/nombre de objeto desconocido pueden provocar un error de secuencia de comandos. Para las coordenadas, 0 también significa X/Y/Z o tolerancia no válida. 1 significa aceptar solo la tarea en segundo plano; La llegada y la ocupación futura aún no se han confirmado.
- Exactamente un modo Follow por cliente: carácter o coordenadas. Una llamada exitosa reemplaza nuevamente el objetivo y los parámetros. Un desafío fallido no anula el objetivo anterior. Para seguir a un personaje, este ya debe estar en la lista de Móviles cargados dentro de ClientViewRange; el punto de coordenadas puede estar más lejos que la vista.
- Al alcanzar una distancia cercana al personaje, la marcha se detiene, pero el modo permanece activado y reanuda el movimiento cuando el objetivo se aleja. Cerca del punto de referencia, la tarea se completa si se cumplen la tolerancia X/Y y la Z exacta. El comando no informa una accesibilidad garantizada de la ruta cuando se inicia.
- Follow(), Follow(0), MoverStop(), el movimiento manual del mouse/flecha, una nueva ruta de script o el seguimiento de un cliente estándar detendrán este modo. TerminateAll/Terminate("all") también lo detiene. Cancelar un script de propietario que aún se está ejecutando lo detiene Follow.
- Ambos modos terminan cuando el mapa o el personaje cambian, el jugador muere o la conexión se desconecta. Seguir al personaje también se detiene cuando el objetivo desaparece de la memoria/vista. La aparición posterior de un objetivo no activa automáticamente el modo: se necesita un nuevo Follow.
- Cerrar IDE no detiene el modo. La terminación normal de un script en ejecución deja Follow habilitado. Una pausa de script no es en sí misma una pausa para ese modo de cliente; antes de hacer una pausa, use Follow(0) cuando el movimiento necesite detenerse.
- Pathfinder calcula la ruta en fragmentos en la transmisión del juego; una búsqueda incompleta no se reinicia. Para mobile la actualización de ruta normal se limita a 500 ms. Después de un fallo o terminación de una ruta sin aproximación, los primeros tres retrasos de reintento son 1000 ms, luego 2000, 4000 y un máximo de 5000 ms. El contador de rebotes se reinicia cuando cambia el jugador o el objetivo X/Y/Z; cambiar el objetivo puede reducir la espera hasta 500 ms. No hay un límite general en el número de repeticiones para un objetivo mobile disponible: el modo puede permanecer activo sin moverse, así que configúrelo en transcurrido o deténgalo explícitamente. La tarea de coordenadas finaliza cuando la ruta falla por completo.
- Campos de distancia/tiempo: distancia: distancia actual al objetivo en celdas max(abs(dx),abs(dy)); altura — diferencia absoluta Z en unidades mundiales; transcurrido: milisegundos desde que se aceptó este Follow. distancia > 12 se detiene cuando se mueve más de 12 celdas, transcurrida >= 30000 - después de 30 segundos. Un éxito repetido Follow inicia la cuenta regresiva nuevamente.
- El estado de tu personaje: self.hp / self.mana / self.stam - valores actuales; self.hppercent / self.manapercent / self.stampercent - porcentajes 0..100 del máximo correspondiente. Máximo desconocido (<=0) significa valor desconocido: la condición para esta característica no se activa, en lugar de recibir el 0 ficticio.
- Campos lógicos para tu personaje: self.poisoned (envenenado), self.paralyzed (paralizado), self.hidden (oculto). Valores 1/0. En la matriz de condiciones Follow, la regla para el campo "self.paralyzed" con el operador "=" y el valor true deja de seguirse cuando se paraliza. Este es el nombre de cadena del campo de regla, no la variable C# self.
- Campos de destino: target.dead - muerto mobile, target.hidden - oculto, target.visible - visible para el cliente (no CheckLOS), target.hp / target.hppercent - cargado HP/percent. Si se desconoce HP max, la condición HP falla. El servidor puede enviar la escala relativa HP del personaje de otra persona, por lo que hppercent le resulta más conveniente.
- Campos de destino adicionales: target.notoriety - estado 0..7 (0 desconocido, 1 Inocente, 2 Aliado, 3 Gris, 4 Criminal, 5 Enemigo, 6 Asesino, 7 Invulnerable); objetivo.body - numérico graphic del cuerpo. Ésta no es ropa type. Por ejemplo, target.notoriety != 2 deja de rastrear cuando se pierde el estado de Aliado.
- Cuando se llama, se captura una copia de las condiciones, incluidos los umbrales numéricos. Cambiar la matriz/variable de origen no actualiza el modo; repita Follow con la nueva matriz. El modo cancelado no se reanuda cuando ya no se cumple la condición.
- Las condiciones se verifican tanto durante el movimiento como cuando el personaje ya está cerca del objetivo. Se verifica una lista regular de hasta elementos 64 en un cuadro de juego, la siguiente verificación no es antes que después de 250 ms. Una lista más grande: 64 elementos por cuadro, luego una pausa 250 ms. El campo transcurrido puede detenerse más tarde del umbral durante la duración de la verificación/cuadro: no es un cronómetro preciso.
- Hasta que no se complete la primera comprobación de toda la lista no se inicia una nueva ruta. Si la condición ya se cumple, Follow devolverá 1 para la solicitud aceptada y luego se detendrá en la actualización sin el primer paso. Es posible que ya se hayan enviado paquetes de pasos del movimiento anterior.
- Las nuevas condiciones no desactivan los motivos de detención obligatoria: pérdida de objetivo/jugador/tarjeta/enlace, muerte del jugador, cancelación del propietario, Terminate todos y movimientos manuales/de otro tipo. El código de script no se ejecuta en el hilo del juego; Solo se verifican los valores locales enumerados.
- Formas de coordenadas: Follow(x,y,z,distancia,corriendo) y Follow(x,y,z,distancia,corriendo,stopConditions). Los primeros cinco argumentos son obligatorios. Follow(x,y,z) no es una notación abreviada para coordenadas: los tres argumentos todavía significan objetivo, distancia, carrera.
- En el modo de coordenadas, la distancia en la condición significa la distancia restante a lo largo de X/Y hasta el punto, la altura es la diferencia absoluta con respecto a su Z; transcurrido y todo self.* funciona como de costumbre. Los campos target.* no son válidos: el punto no tiene HP, cuerpo ni estado. Intentar pasarlos provoca un error de secuencia de comandos hasta que se reemplaza el modo anterior.
- Las condiciones se comprueban antes de la primera ruta, durante su cálculo y mientras el personaje se mueve. La activación de cualquier condición elimina la tarea y cancela la ruta que le pertenece. La frecuencia y el procesamiento de listas grandes es el mismo que seguir a un personaje; Es posible que se completen los pasos ya enviados al servidor.
- La tarea de coordenadas finaliza cuando se alcanza el punto o la búsqueda y movimiento falla/finaliza sin llegar a él. No se activan infinitos reintentos a un punto inalcanzable. Se conservan los recálculos internos normales de Pathfinder para obstáculos. Una vez completado, abandonar la ubicación no reanuda la tarea.
- Si Pathfinder ya envió los últimos pasos y completó la ruta, pero esos pasos aún se están ejecutando/esperando confirmación, la tarea continúa verificando las condiciones. La cola de pasos enviados en sí no se borra: debe ser procesada mediante el mecanismo normal de movimiento y confirmación del servidor.
- La lista se puede ensamblar a través de List.Add al DO... final del ciclo o FOR y luego pasar una vez a checks.ToArray() como último argumento del formulario apropiado. No es necesario volver a llamar a Follow en cada iteración: esto reemplaza el modo y restablece el tiempo transcurrido. El número de filas no se limita a un número pequeño, sino que el conjunto de campos admitidos se limita a los campos enumerados anteriormente.
- Después de 2000 ms sin cambiar el X/Y/Z del jugador, mobile-Follow puede volver a solicitar la ruta al objetivo estacionario. La verificación se realiza solo cuando llega la próxima fecha límite, fuera de la búsqueda, después de que se liberan Player.Steps y la cola de Walker, y cuando se permite el siguiente paso. No tiene ningún coste moverse a un ritmo lento y esperar confirmaciones; Los pasos enviados no se borran. Coordinate Follow no desencadena una repetición externa interminable: la restauración de su ruta está a cargo del Pathfinder limitado.
- El Pathfinder general almacena hasta 8 prohibiciones direccionales X/Y/Z temporales durante 2000 ms, solo en caso de movimiento rechazado de la solicitud activa correspondiente. La rotación, la secuencia desconocida, la resincronización y la solicitud antigua/extraña no crean dicha prohibición. Una nueva solicitud externa y la pérdida del contexto del mapa/jugador los borra. La búsqueda de geometría cargada intenta omitir la transición; es no conocer todos los obstáculos del servidor. Sin cambiar el X/Y/Z del reproductor, se permiten hasta 8 recálculos internos con una pausa de al menos 40 ms. No existe un camino completo o este presupuesto se ha agotado: la ruta termina. Luego, la tarea coordinada se completa después de procesar los pasos enviados; mobile-Follow puede intentarlo nuevamente debido a su retraso.
- El controlador compara el número de su propia solicitud de movimiento, no el hecho AutoWalking: el final natural del camino no se considera un comando extraño. StopOwnedPath transfiere el número almacenado a StopAutoWalkIfRequestGeneration. La nueva solicitud externa finaliza la antigua Follow; detenerlo no cancela la nueva ruta de otra persona.
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.
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.Follow();
UO.Print("Follow: " + Convert.ToString(result));Parámetros y flujo de ejecución:
- líder - serial del último objetivo. La unidad confirma la aceptación del régimen, no la llegada. Una vez finalizado el método, el modo continúa funcionando hasta que el objetivo se detiene/pierde.
var leader = UO.GetSerial("lasttarget");
var accepted = UO.Follow(leader);
if (Truth(Truth(accepted) == true))
{
UO.Print("Following is enabled; script continues");
}
else
{
UO.Print("Select a loaded nearby character");
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parámetros y flujo de ejecución:
- UO.Wait se mide en milisegundos. Follow(0) desactiva el siguiente modo general; Los movimientos posteriores del objetivo ya no causan movimiento.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var leader = UO.GetSerial("lasttarget");
if (Truth(UO.Follow(leader, 3, false) == 1))
{
await Delay(10000);
UO.Follow(0);
UO.Print("Following stopped");
}
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;Parámetros y flujo de ejecución:
- distancia=2, corriendo=true; expectativas máximas de 20 sobre 500 ms. Exists comprueba la presencia de un objeto, pero no la accesibilidad del camino.
finallydetiene el modo durante la salida/error normal; La cancelación de emergencia del propietario también corre a cargo del cliente.
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 leader = UO.GetSerial("leader");
if (Truth(UO.Follow(leader, 2, true) == 0))
{
UO.Print("Cannot start following");
return null;
}
try
{
var attempts = 0;
while (Truth(attempts < 20) && Truth(UO.Exists(leader)))
{
await Delay(500);
attempts = attempts + 1;
}
}
finally
{
UO.Follow();
}
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;
}Parámetros y flujo de ejecución:
- Detenerse por CUALQUIER condición: el objetivo está más lejos de las celdas 12 O nuestro HP no han pasado más de 40% O 30 segundos. Este no es AND. StopWhen se proporciona en su totalidad, se puede incluir en Incluir. Uno significa aceptación, no llegada.
var leader = UO.GetSerial("lasttarget");
dynamic[] conditions = new dynamic[checked((int)(2) + 1)];
conditions[0] = StopWhen("distance", ">", 12);
conditions[1] = StopWhen("self.hppercent", "<=", 40);
conditions[2] = StopWhen("elapsed", ">=", 30000);
var accepted = UO.Follow(leader, 2, true, conditions);
if (Truth(accepted == 0))
{
UO.Print("Cannot follow this target");
}
dynamic StopWhen(dynamic field, dynamic comparison, dynamic threshold)
{
dynamic[] rule = new dynamic[checked((int)(2) + 1)];
rule[0] = field;
rule[1] = comparison;
rule[2] = threshold;
return rule;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parámetros y flujo de ejecución:
- Nos detenemos si el objetivo ha desaparecido/muerto/ya no es un Aliado, no queda más de 5 de resistencia o la diferencia en Z ha excedido 16. false significa caminar. ToArray pasa una lista de líneas de condición; El tamaño no se especifica de antemano. Si el objetivo ya no es un aliado, el movimiento no comenzará.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var checks = new List<object?>();
checks.Add(StopWhen("target.hidden", "=", true));
checks.Add(StopWhen("target.dead", "=", true));
checks.Add(StopWhen("target.notoriety", "<>", 2));
checks.Add(StopWhen("self.stam", "<=", 5));
checks.Add(StopWhen("height", ">", 16));
var leader = UO.GetSerial("lasttarget");
var conditions = checks.ToArray();
UO.Follow(leader, 2, false, conditions);
return null;
}
dynamic StopWhen(dynamic field, dynamic comparison, dynamic threshold)
{
dynamic[] rule = new dynamic[checked((int)(2) + 1)];
rule[0] = field;
rule[1] = comparison;
rule[2] = threshold;
return rule;
}Parámetros y flujo de ejecución:
- Distancia mantenida 1, condición de parada <=3; comprobar cada 250 ms puede notar un logro retrasado. El tiempo de espera de 15000 ms no permite el seguimiento indefinidamente. Devolver Follow sigue significando aceptación, sin llegar a tres casillas.
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[] conditions = new dynamic[checked((int)(1) + 1)];
conditions[0] = StopWhen("distance", "<=", 3);
conditions[1] = StopWhen("elapsed", ">=", 15000);
UO.Follow(UO.GetSerial("lasttarget"), 1, true, conditions);
return null;
}
dynamic StopWhen(dynamic field, dynamic comparison, dynamic threshold)
{
dynamic[] rule = new dynamic[checked((int)(2) + 1)];
rule[0] = field;
rule[1] = comparison;
rule[2] = threshold;
return rule;
}
}Parámetros y flujo de ejecución:
- while recopila una condición separada para cada elemento de estado. Deténgase en el estado 5 O 6, propio HP <=40% O después de 30000 ms. Los estados vacíos omitirán el ciclo, pero las dos condiciones siguientes permanecerán. Agregue nuevas líneas hasta Follow; un cambio posterior a Lista no cambia la copia ya instalada. Para verificaciones de antecedentes, no es necesario repetir el cuerpo del bucle.
var statuses = new List<object?>();
statuses.Add(5);
statuses.Add(6);
var checks = new List<object?>();
var index = 0;
while (index < statuses.Count)
{
checks.Add(StopWhen("target.notoriety", "=", statuses[index]));
index += 1;
}
checks.Add(StopWhen("self.hppercent", "<=", 40));
checks.Add(StopWhen("elapsed", ">=", 30000));
var accepted = UO.Follow(UO.GetSerial("lasttarget"), 2, true, checks.ToArray());
if (Truth(accepted == 0))
{
UO.Print("Select a loaded nearby character");
}
dynamic StopWhen(dynamic field, dynamic comparison, dynamic threshold)
{
dynamic[] rule = new dynamic[checked((int)(2) + 1)];
rule[0] = field;
rule[1] = comparison;
rule[2] = threshold;
return rule;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;8. Expresiones propias al final del bucle UNTIL y una parada obligatoria en Finalmente - función de script
Parámetros y flujo de ejecución:
- StopEscort(líder, startedAt) devuelve bool compatible con 1/0: objetivo más allá de las celdas 12 O propio HP <=30 O 30 han pasado segundos. Añadir || (otra_condición); Para una combinación obligatoria de dos controles, utilice (condiciónA && condiciónB). El HP desconocido se puede leer como 0; el ejemplo luego se niega a comenzar. Mientras se ejecuta el script, verifica las expresiones aproximadamente cada 250 ms; pausar el script detiene estas comprobaciones. Finalmente envía una parada en caso de salida/error normal; La cancelación del propietario también es rastreada por el cliente. Si el objetivo ha desaparecido y el cliente ya se ha detenido Follow, este ciclo finalizará según sus propios términos, a más tardar en la verificación del tiempo de espera. Para trabajar después del final del método, utilice el cuarto argumento, como en los ejemplos anteriores.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var leader = UO.GetSerial("lasttarget");
var startedAt = Now();
if (Truth(leader == "0x00000000") || Truth(StopEscort(leader, startedAt)))
{
return null;
}
if (Truth(UO.Follow(leader, 2, true) == 0))
{
return null;
}
try
{
do
{
UO.Wait(250);
}
while (!StopEscort(leader, startedAt));
}
finally
{
UO.Follow(0);
}
return null;
}
dynamic StopEscort(dynamic leader, dynamic startedAt)
{
return (UO.GetDistance(leader) > 12) || (UO.GetHP("self") <= 30) || (Now() - startedAt >= 30000);
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parámetros y flujo de ejecución:
- Cinco argumentos: X=1445, Y=1690, Z=0, tolerancia X/Y=0, ejecutar. La devolución 1 significa aceptación, no llegada ya completada. Una vez allí, la tarea se apagará por completo. Para detenerse anticipadamente manualmente, llame al UO.Follow(0).
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 accepted = UO.Follow(1445, 1690, 0, 0, true);
if (Truth(accepted == 0))
{
UO.Print("Coordinate task was not accepted");
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}Parámetros y flujo de ejecución:
- En HP <=40%, parálisis, o después de 30 segundos, el cliente detiene su ruta actual. De lo contrario, la tarea finalizará dentro de dos celdas X/Y de (1445,1690), estrictamente en Z=0. Las comprobaciones continúan tanto durante la búsqueda de caminos como durante el movimiento; Esta no es una verificación única antes del inicio. target.* no se aplica aquí.
var checks = new List<object?>();
checks.Add(StopWhen("self.hppercent", "<=", 40));
checks.Add(StopWhen("self.paralyzed", "=", true));
checks.Add(StopWhen("elapsed", ">=", 30000));
UO.Follow(1445, 1690, 0, 2, true, checks.ToArray());
dynamic StopWhen(dynamic field, dynamic comparison, dynamic threshold)
{
dynamic[] rule = new dynamic[checked((int)(2) + 1)];
rule[0] = field;
rule[1] = comparison;
rule[2] = threshold;
return rule;
}Parámetros y flujo de ejecución:
- distancia=0 en la llamada especifica una llegada exacta, pero la condición distancia<=3 finaliza la tarea antes, cuando la siguiente verificación detecta dicha distancia. false significa caminar. La diferencia Z>16 o 20000 ms también detiene la tarea. La dirección no garantiza la transitabilidad; reemplace el desplazamiento con su punto de ruta.
Intervalo mínimo de paso: caminar - caminar 400 ms, correr 200 ms; montar a caballo - caminar 200 ms, correr 100 ms.
Estos son límites de cliente estándar, no configuraciones definidas automáticamente para su fragmento. La velocidad del servidor y los modos de vuelo se cuentan por separado. Los temporizadores de guiones pueden ralentizar el movimiento, pero no reducen estos límites.
Los pasos, las rutas, Follow, los controles del mouse/teclas y el mapa utilizan la cola compartida del personaje. Reemplazar la ruta, girar o ajustar la posición por parte del servidor no cancela la pausa restante después de la solicitud del paso. Después del retraso, no hay una ráfaga rápida para compensar los fotogramas perdidos. La espera de confirmación, los obstáculos y la mala comunicación pueden ralentizar el movimiento.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var checks = new List<object?>();
checks.Add(StopWhen("distance", "<=", 3));
checks.Add(StopWhen("height", ">", 16));
checks.Add(StopWhen("elapsed", ">=", 20000));
var x = UO.GetX("self") + 10;
var y = UO.GetY("self");
var z = UO.GetZ("self");
UO.Follow(x, y, z, 0, false, checks.ToArray());
return null;
}
dynamic StopWhen(dynamic field, dynamic comparison, dynamic threshold)
{
dynamic[] rule = new dynamic[checked((int)(2) + 1)];
rule[0] = field;
rule[1] = comparison;
rule[2] = threshold;
return rule;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.GetDir();
int UO.GetDir(object? arg0);Lee la dirección del carácter del modelo del cliente.
-
id: objeto opcional solo en los formatos de parámetro único especificados: serial número/cadena hexadecimal, "self", "lasttarget" o nombre AddObject. Esto no es graphic/type. Sin argumentos, se lee el propio carácter. Antes de leer otro objeto, marque UO.Exists; un nombre desconocido no abre el alcance.
int — dirección mobile sin bit en marcha: 0=N, 1=NE, 2=E, 3=SE, 4=S, 5=SW, 6=W, 7=NW. Para desconocido, mobile devuelve 0, que también significa norte.
- 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.
- Estas son funciones de lectura: al asignar el resultado a una variable se guarda la instantánea. No cambia las características del personaje. Los nombres no distinguen entre mayúsculas y minúsculas; utilice exactamente el formulario que se muestra con el número requerido de argumentos.
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.
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.GetDir();
UO.Print("GetDir: " + Convert.ToString(result));Parámetros y flujo de ejecución:
- La llamada sin argumentos hace referencia a self. La dirección del personaje se almacena en valor.
- Convertir.ToString convierte el número que se generará y no cambia el significado del resultado.
var value = UO.GetDir();
UO.Print("GetDir: " + Convert.ToString(value));Parámetros y flujo de ejecución:
- El valor se lee una vez sin ningún argumento. La dirección del personaje 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 await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var value = UO.GetDir();
if (Truth(value == 2))
{
UO.Print("Facing east");
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parámetros y flujo de ejecución:
- El argumento único selecciona el objeto lasttarget; su serial debe ser conocido por el cliente. El gráfico/type no se transfiere aquí.
- Los datos de otro objeto pueden ser desconocidos incluso si Exists es positivo. Para las coordenadas de un artículo en una bolsa, se obtiene la posición del contenedor, no el punto mundial.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
if (Truth(UO.Exists("lasttarget")))
{
var targetValue = UO.GetDir("lasttarget");
UO.Print("Selected value: " + Convert.ToString(targetValue));
}
else
{
UO.Print("Target is not loaded");
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.GetDirection();
dynamic UO.GetDirection(object? arg0);Lee la dirección del carácter del modelo del cliente.
-
ObjID: objeto opcional solo en los formatos de parámetro único especificados: serial número/cadena hexadecimal, "self", "lasttarget" o nombre AddObject. Esto no es graphic/type. Sin argumentos, se lee el propio carácter. Antes de leer otro objeto, marque UO.Exists; un nombre desconocido no abre el alcance.
int — dirección mobile sin bit en marcha: 0=N, 1=NE, 2=E, 3=SE, 4=S, 5=SW, 6=W, 7=NW. Para desconocido, mobile devuelve 0, que también significa norte.
- 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.
- Estas son funciones de lectura: al asignar el resultado a una variable se guarda la instantánea. No cambia las características del personaje. Los nombres no distinguen entre mayúsculas y minúsculas; utilice exactamente el formulario que se muestra con el número requerido de argumentos.
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.
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.GetDirection();
UO.Print("GetDirection: " + Convert.ToString(result));Parámetros y flujo de ejecución:
- La llamada sin argumentos hace referencia a self. La dirección del personaje se almacena en valor.
- Convertir.ToString convierte el número que se generará y no cambia el significado del resultado.
var value = UO.GetDirection();
UO.Print("GetDirection: " + Convert.ToString(value));Parámetros y flujo de ejecución:
- El valor se lee una vez sin ningún argumento. La dirección del personaje 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 await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var value = UO.GetDirection();
if (Truth(value == 2))
{
UO.Print("Facing east");
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parámetros y flujo de ejecución:
- El argumento único selecciona el objeto lasttarget; su serial debe ser conocido por el cliente. El gráfico/type no se transfiere aquí.
- Los datos de otro objeto pueden ser desconocidos incluso si Exists es positivo. Para las coordenadas de un artículo en una bolsa, se obtiene la posición del contenedor, no el punto mundial.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
if (Truth(UO.Exists("lasttarget")))
{
var targetValue = UO.GetDirection("lasttarget");
UO.Print("Selected value: " + Convert.ToString(targetValue));
}
else
{
UO.Print("Target is not loaded");
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.GetPathArray(object? arg0, object? arg1, object? arg2, object? arg3);Devuelve la ruta desde la posición actual del personaje a X/Y sin realizar ningún movimiento.
-
Xdst— Coordenada mundial X del destino, 0...65535. Esto no es serial ni una posición dentro de una encía. -
x— Coordenada mundial X del destino, 0...65535. Esto no es serial ni una posición dentro de una encía. -
Ydst— Coordenada mundial Y de destino, 0...65535. -
y— Coordenada mundial Y de destino, 0...65535. -
Optimized- true permite transiciones diagonales; false deja cuatro direcciones rectas en esta forma compatible. Esto es diferente del significado Optimizado de MoveXY. -
Accuracy— Tolerancia para X e Y en las celdas: ambas desviaciones deben encajar dentro de ella. El valor está limitado al rango 0..20; 0 requiere X/Y preciso.
Matriz de registros [x,y,z], cada campo es un int. [0] de la matriz exterior es el punto de partida; la última entrada está dentro de la tolerancia objetivo especificada. El número de pasos es ArrayLength(ruta)-1 solo para una matriz que no esté vacía. Una matriz vacía [] significa que no se obtiene la ruta válida completa (objetivo/mapa inalcanzable, restricciones o límite de búsqueda). Si el punto de partida ya es adecuado, se devuelve un registro y el número de pasos es 0. La ruta parcial no se devuelve.
- El equipo sólo calcula la ruta; no inicia movimiento ni abre puertas. Para ejecutar, use NewMoveXY/MoveXYZ y verifique su propio resultado.
- La búsqueda evita obstáculos al considerar que los movimientos adyacentes tienen el mismo coste; en un mapa constante se busca el camino con el menor número de pasos. Se comprueba la permeabilidad real de cada costilla, incluida la altura y las limitaciones de las diagonales del cliente.
- No más de 4096 nodos abiertos y no más de 4096 pasos. El límite de trabajo puede dar como resultado una matriz vacía incluso si hay una ruta larga y compleja; Divida las rutas largas en secciones.
- En el cliente, el cálculo se divide en porciones de hasta 32 nodos con una verificación de presupuesto de aproximadamente 1 ms entre nodos. La cancelación se comprueba entre raciones. La lectura de la tarjeta permanece en el hilo del juego; no es una promesa de un tiempo de lectura de disco individual fijo.
- El mapa puede cambiar después de la verificación: los personajes se mueven, las puertas se cierran, el servidor corrige la situación. La matriz resultante es un plan para los datos locales disponibles, no una confirmación del servidor.
- SetBadLocation excluye celdas, SetBadObject excluye áreas alrededor de objetos mundiales cargados adecuados. Se utiliza una instantánea de sus listas de tiempo de ejecución en el momento de la solicitud; Las prohibiciones de otro lanzamiento no se heredan. No se comprueba la posición de la celda inicial: está especificada por el código de llamada. No puede utilizar una Z arbitraria dentro de una pared como posición inicial válida.
- La carta actual, la fuente X/Y/Z y el objetivo Z se toman del personaje. Tolerancia Z=255. No hay filtros móviles/estáticos adicionales ni permiso para puertas cerradas en forma de cuatro argumentos.
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.
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.GetPathArray(UO.GetX() + 5, UO.GetY(), true, 0);
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parámetros y flujo de ejecución:
- Xdst: cinco celdas al este; Ydst ex; Optimizado=true; Precisión=0.
- El recuento incluye el punto de partida. La resta 1 se realiza solo después de verificar si hay una matriz que no esté vacía.
var path = UO.GetPathArray(UO.GetX() + 5, UO.GetY(), true, 0);
var count = ArrayLength(path);
if (Truth(count > 0))
{
UO.Print("Steps: " + Convert.ToString(count - 1));
}
else
{
UO.Print("Complete path 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;Parámetros y flujo de ejecución:
- Objetivo 1445/1690; Optimizado=false excluye diagonales; Precisión=1 resuelve la celda más cercana en el cuadrado de tolerancia.
- punto[0]/[1]/[2] - X/Y/Z. No es graphic, serial ni tipo de superficie.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var path = UO.GetPathArray(1445, 1690, false, 1);
var i = 0;
while (Truth(i < ArrayLength(path)))
{
var point = path[i];
UO.Print(Convert.ToString(point[0]) + "," + Convert.ToString(point[1]) + "," + Convert.ToString(point[2]));
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;Parámetros y flujo de ejecución:
- El primer equipo sólo cuenta el camino. El segundo verifica/ejecuta el movimiento nuevamente, callback=0, timeout=5000.
- Si solo necesitas ir, el GetPathArray preliminar es opcional y agrega trabajo.
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() + 3;
var y = UO.GetY();
var path = UO.GetPathArray(x, y, true, 0);
if (Truth(ArrayLength(path) > 0))
{
var ok = UO.NewMoveXY(x, y, true, 0, false, 0, 5000);
UO.Print("Movement result: " + Convert.ToString(ok));
}
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;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.GetPathArray3D(object? arg0, object? arg1, object? arg2, object? arg3, object? arg4, object? arg5, object? arg6, object? arg7, object? arg8, object? arg9);
dynamic UO.GetPathArray3D(object? arg0, object? arg1, object? arg2, object? arg3, object? arg4, object? arg5, object? arg6, object? arg7, object? arg8, object? arg9, object? arg10);
dynamic UO.GetPathArray3D(object? arg0, object? arg1, object? arg2, object? arg3, object? arg4, object? arg5, object? arg6, object? arg7, object? arg8, object? arg9, object? arg10, object? arg11);
dynamic UO.GetPathArray3D(object? arg0, object? arg1, object? arg2, object? arg3, object? arg4, object? arg5, object? arg6, object? arg7, object? arg8, object? arg9, object? arg10, object? arg11, object? arg12);
dynamic UO.GetPathArray3D(object? arg0, object? arg1, object? arg2, object? arg3, object? arg4, object? arg5, object? arg6, object? arg7, object? arg8, object? arg9, object? arg10, object? arg11, object? arg12, object? arg13);
dynamic UO.GetPathArray3D(object? arg0, object? arg1, object? arg2, object? arg3, object? arg4, object? arg5, object? arg6, object? arg7, object? arg8, object? arg9, object? arg10, object? arg11, object? arg12, object? arg13, object? arg14);
dynamic UO.GetPathArray3D(object? arg0, object? arg1, object? arg2, object? arg3, object? arg4, object? arg5, object? arg6, object? arg7, object? arg8, object? arg9, object? arg10, object? arg11, object? arg12, object? arg13, object? arg14, object? arg15);Calcula una matriz del camino completo entre dos puntos del mundo con control de altura y filtros adicionales.
-
startX— Mundo inicial X, 0...65535. -
startY— Mundo inicial Y, 0...65535. -
startZ— Altura inicial -128...127. -
finishX— Mundo objetivo X, 0...65535. -
finishY— Mundo objetivo Y, 0...65535. -
finishZ— Altura del objetivo -128...127. -
map: número de la tarjeta actualmente cargada, por ejemplo UO.WorldNum(). El otro mapa proporciona una matriz vacía que incluye X/Y/Z coincidente. -
accuracyXY— Tolerancia para X e Y en las celdas: ambas desviaciones deben encajar dentro de ella. El valor está limitado al rango 0..20; 0 requiere X/Y preciso. -
accuracyZ— Tolerancia de altura: abs (Z real - Z requerida), limitada por 0...255. El cero requiere una altitud precisa; 255 prácticamente desactiva el límite Z. -
run: indicador de ejecución compatible requerido. La solicitud no mueve nada; En este formulario, Optimizado siempre es true, por lo que ejecutar no cambia la secuencia de celdas ni el número de pasos. -
maxSteps: límite opcional en el número de bordes de ruta, sin un punto de partida. 0/negativo/ausente utiliza el límite general 4096. Aquí se consideran las células, en contraste con los cambios observados en NewMoveXY. -
maxDistance: límite opcional en la distancia inicial máxima (abs(dx),abs(dy)) al objetivo. 0/ausencia lo desactiva. Esta no es la desviación permitida durante el recorrido ni la longitud del camino encontrado. -
avoidMobiles- true excluye los caracteres cargados X/Y, excepto self, por instantánea al comienzo de la llamada; La altura de este filtro no se tiene en cuenta. El valor predeterminado es false. Se sigue aplicando la verificación normal de autorización del cliente. -
avoidStatics- true excluye una celda con cualquier entrada estática, incluso transitable o a diferente altura. El valor predeterminado es false. Se trata de un filtro estricto y no sólo de una prohibición de muros infranqueables. -
allowDoors- true permite un camino tentativo a través de un mosaico de puerta encontrado, incluso si la puerta cerrada no pasa la verificación normal. El valor predeterminado es false. La puerta no se abre; El acceso, Z y la permeabilidad deberán comprobarse nuevamente durante la ejecución. -
allowDiagonal- true/ausente permite ocho direcciones con verificación de ángulo; false: solo cuatro direcciones hacia adelante.
Matriz de registros [x,y,z], cada campo es un int. [0] de la matriz exterior es el punto de partida; la última entrada está dentro de la tolerancia objetivo especificada. El número de pasos es ArrayLength(ruta)-1 solo para una matriz que no esté vacía. Una matriz vacía [] significa que no se obtiene la ruta válida completa (objetivo/mapa inalcanzable, restricciones o límite de búsqueda). Si el punto de partida ya es adecuado, se devuelve un registro y el número de pasos es 0. La ruta parcial no se devuelve.
- El equipo sólo calcula la ruta; no inicia movimiento ni abre puertas. Para ejecutar, use NewMoveXY/MoveXYZ y verifique su propio resultado.
- La búsqueda evita obstáculos al considerar que los movimientos adyacentes tienen el mismo coste; en un mapa constante se busca el camino con el menor número de pasos. Se comprueba la permeabilidad real de cada costilla, incluida la altura y las limitaciones de las diagonales del cliente.
- No más de 4096 nodos abiertos y no más de 4096 pasos. El límite de trabajo puede dar como resultado una matriz vacía incluso si hay una ruta larga y compleja; Divida las rutas largas en secciones.
- En el cliente, el cálculo se divide en porciones de hasta 32 nodos con una verificación de presupuesto de aproximadamente 1 ms entre nodos. La cancelación se comprueba entre raciones. La lectura de la tarjeta permanece en el hilo del juego; no es una promesa de un tiempo de lectura de disco individual fijo.
- El mapa puede cambiar después de la verificación: los personajes se mueven, las puertas se cierran, el servidor corrige la situación. La matriz resultante es un plan para los datos locales disponibles, no una confirmación del servidor.
- SetBadLocation excluye celdas, SetBadObject excluye áreas alrededor de objetos mundiales cargados adecuados. Se utiliza una instantánea de sus listas de tiempo de ejecución en el momento de la solicitud; Las prohibiciones de otro lanzamiento no se heredan. No se comprueba la posición de la celda inicial: está especificada por el código de llamada. No puede utilizar una Z arbitraria dentro de una pared como posición inicial válida.
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.
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.GetPathArray3D(UO.GetX(), UO.GetY(), UO.GetZ(), UO.GetX() + 4, UO.GetY(), UO.GetZ(), UO.WorldNum(), 0, 0, false);
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parámetros y flujo de ejecución:
- Los primeros tres valores son los X/Y/Z originales; los siguientes tres son el propósito.
- map=WorldNum(), accuracyXY=0, accuracyZ=0 requieren una posición precisa. run=false no provoca caminar.
var x = UO.GetX();
var y = UO.GetY();
var z = UO.GetZ();
var path = UO.GetPathArray3D(x, y, z, x + 4, y, z, UO.WorldNum(), 0, 0, false);
if (Truth(ArrayLength(path) > 0))
{
UO.Print("Steps: " + Convert.ToString(ArrayLength(path) - 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;Parámetros y flujo de ejecución:
- Objetivo 1445/1690/20; accuracyXY=1, accuracyZ=2; run=true sigue siendo un indicador de compatibilidad.
- maxSteps=80, maxDistance=30; avoidMobiles=true, avoidStatics=false, allowDoors=true, allowDiagonal=false. La matriz puede estar vacía.
- El espacio libre de las puertas es una suposición de planificación; no hay garantía de apertura y paso.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var path = UO.GetPathArray3D(UO.GetX(), UO.GetY(), UO.GetZ(), 1445, 1690, 20, UO.WorldNum(), 1, 2, true, 80, 30, true, false, true, false);
UO.Print("Points: " + Convert.ToString(ArrayLength(path)));
return null;
}
int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;Parámetros y flujo de ejecución:
- accuracyXY=2/accuracyZ=5 resuelve el punto adecuado más cercano; maxSteps=100.
- last es la última entrada en el plan, no la posición actual del personaje. El equipo no lo mueve.
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 path = UO.GetPathArray3D(UO.GetX(), UO.GetY(), UO.GetZ(), 1445, 1690, 0, UO.WorldNum(), 2, 5, false, 100);
var count = ArrayLength(path);
if (Truth(count > 0))
{
var last = path[count - 1];
UO.Print("X=" + Convert.ToString(last[0]) + " Y=" + Convert.ToString(last[1]) + " Z=" + Convert.ToString(last[2]));
}
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;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.GetRun();
int UO.GetRun(object? arg0);Comprueba la bandera de ejecución en la última dirección conocida mobile.
-
id— Obligatorio serial/ID de un objeto específico: int, cadena hexadecimal o alias self, backpack, lasttarget, lastobject, lastcontainer, laststatus, finditem, lastcorpse o the nombre AddObject. Esto no es graphic/type. El nombre no especificado se resuelve en 0; el comando no abre ningún objetivo nuevo. GetRun también tiene la forma GetRun() para self. -
ObjID— Obligatorio serial/ID de un objeto específico: int, cadena hexadecimal o alias self, backpack, lasttarget, lastobject, lastcontainer, laststatus, finditem, lastcorpse o the nombre AddObject. Esto no es graphic/type. El nombre no especificado se resuelve en 0; el comando no abre ningún objetivo nuevo. GetRun también tiene la forma GetRun() para self. -
MobID— Obligatorio serial/ID de un objeto específico: int, cadena hexadecimal o alias self, backpack, lasttarget, lastobject, lastcontainer, laststatus, finditem, lastcorpse o the nombre AddObject. Esto no es graphic/type. El nombre no especificado se resuelve en 0; el comando no abre ningún objetivo nuevo. GetRun también tiene la forma GetRun() para self.
int 1 - cargado mobile tiene el atributo Direction.Running. int 0: falta el atributo, el objeto no es mobile, desconocido o eliminado. La última bandera en marcha puede conservarse después de detenerse. Esta no es la actividad de la ruta, ni la velocidad ni el número de pasos restantes. Para mover self use Moving() también.
El resultado del comando es una bandera numérica: 1 significa una condición cumplida, 0 significa una condición no cumplida. Después de var resultado = comando(...) verifique si (resultado! = 0) o si (resultado == 0). Guarde el resultado de una llamada: una llamada repetida puede realizar la acción nuevamente o leer el estado que ya cambió.
- Se lee el modelo del cliente local; No hay solicitudes al servidor, ni esperas ni movimientos.
- El resultado se refiere al momento de la lectura. Después de UO.Wait u otra acción, el objeto y sus indicadores pueden cambiar.
- La última bandera en marcha puede conservarse después de detenerse. Esta no es la actividad de la ruta, ni la velocidad ni el número de pasos restantes. Para mover self también use Moving().
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.
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.GetRun("self");
UO.Print("GetRun: " + Convert.ToString(result));Parámetros y flujo de ejecución:
- El argumento self selecciona explícitamente su carácter. estado: 1/0 únicamente.
- La última bandera en marcha puede conservarse después de detenerse. Esta no es la actividad de la ruta, ni la velocidad ni el número de pasos restantes. Para mover self también use Moving().
var state = UO.GetRun("self");
var moving = UO.Moving();
UO.Print("Running flag: " + Convert.ToString(state));
UO.Print("Self movement active: " + Convert.ToString(moving));Parámetros y flujo de ejecución:
- IsNpc excluye sujeto y objeto desconocido. El objetivo almacena un único serial en lugar de una referencia activa a un lasttarget cambiante.
- El resultado se refiere al campo Direction.Running. Los datos se actualizan solo después de que el cliente recibe el estado apropiado.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var target = UO.GetSerial("lasttarget");
if (Truth(UO.IsNPC(target)))
{
var state = UO.GetRun(target);
UO.Print("Selected mobile state 1/0: " + Convert.ToString(state));
}
else
{
UO.Print("No loaded mobile selected");
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parámetros y flujo de ejecución:
- UO.Wait(500): pausa en milisegundos. Después, se comprueba por separado que mobile todavía existe.
- Se comparan dos fotografías. Es posible que se pierdan los cambios intermedios y esta no es una suscripción continua a los eventos del servidor.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
var target = UO.GetSerial("lasttarget");
if (Truth(UO.IsNPC(target)))
{
var before = UO.GetRun(target);
await Delay(500);
if (Truth(UO.IsNPC(target)))
{
var after = UO.GetRun(target);
if (Truth(before != after))
{
UO.Print("Flag changed: " + Convert.ToString(before) + " -> " + Convert.ToString(after));
}
}
else
{
UO.Print("Mobile left the local world");
}
}
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.GetRunMountTimer();Muestra el intervalo configurado de un paso de carrera de un caballo en milisegundos. Útil para comprobar el modo, estimar el tiempo y guardar la configuración antes de reducir la velocidad temporalmente.
No hay parámetros.
int de 100 a 2000 inclusive: intervalo configurado en milisegundos. El valor predeterminado es 100. Esta es la cantidad de veces, no true/false, no ID, ni la cantidad de celdas pasadas.
- El ajuste se aplica al modo de conducción. El valor estándar y mínimo permitido es 100 ms; el límite superior es 2000 ms. Los otros tres modos tienen configuraciones separadas.
- Este es el intervalo de movimiento local del personaje, no el ping, FPS, el tiempo de espera de búsqueda de ruta o la duración medida del paso del servidor. Aumentar el número ralentiza el movimiento; disminuir por debajo del intervalo estándar no acelera el envío de paquetes.
- El equipo en sí no comienza a moverse, no se monta en la montura y no cambia el modo de caminar/correr. El modo se selecciona mientras se conduce; El cliente también tiene en cuenta el modo de velocidad y el vuelo especificados por el servidor.
- La configuración es general para el movimiento de este cliente: se puede utilizar mediante control manual, ruta de mapa y otros scripts. Cambiándolo temporalmente, mantiene el valor anterior y lo restablece después de la operación; no cambie un modo al mismo tiempo de varios procedimientos.
- Los pasos giratorios y desviados son diferentes de los movimientos normales. La confirmación del servidor, los retrasos en la comunicación y los obstáculos pueden aumentar el tiempo real. El cliente no envía una serie de pasos acelerados para ponerse al día con los fotogramas faltantes.
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.
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.GetRunMountTimer();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parámetros y flujo de ejecución:
- UO.GetRunMountTimer() se llama sin argumentos. delayMs — intervalo de carrera a caballo; otros modos no se miden aquí.
var delayMs = UO.GetRunMountTimer();
UO.Print("Movement delay, ms: " + Convert.ToString(delayMs));Parámetros y flujo de ejecución:
- pasos=5 es el número de pasos a evaluar, no un parámetro de comando. La multiplicación da sólo la contribución de los retrasos configurados; no es una promesa de hora de llegada ni de tiempo de espera de ruta.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var steps = 5;
var delayMs = UO.GetRunMountTimer();
var estimateMs = steps * delayMs;
UO.Print("Step-delay budget, ms: " + Convert.ToString(estimateMs));
return null;
}Parámetros y flujo de ejecución:
- anterior se compara con 100 ms. Se establece el intervalo estándar, se guardan los otros tres modos. El personaje no se mueve más allá del desafío en sí.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
var previous = UO.GetRunMountTimer();
if (Truth(previous > 100))
{
UO.SetRunMountTimer(100);
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.GetRunUnMountTimer();Muestra el intervalo configurado de un paso de caminata en milisegundos. Útil para comprobar el modo, estimar el tiempo y guardar la configuración antes de reducir la velocidad temporalmente.
No hay parámetros.
int de 200 a 2000 inclusive: intervalo configurado en milisegundos. El valor predeterminado es 200. Esta es la cantidad de veces, no true/false, no ID, ni la cantidad de celdas pasadas.
- La configuración se aplica al modo caminar. El valor estándar y mínimo permitido es 200 ms; el límite superior es 2000 ms. Los otros tres modos tienen configuraciones separadas.
- Este es el intervalo de movimiento local del personaje, no el ping, FPS, el tiempo de espera de búsqueda de ruta o la duración medida del paso del servidor. Aumentar el número ralentiza el movimiento; disminuir por debajo del intervalo estándar no acelera el envío de paquetes.
- El equipo en sí no comienza a moverse, no se monta en la montura y no cambia el modo de caminar/correr. El modo se selecciona mientras se conduce; El cliente también tiene en cuenta el modo de velocidad y el vuelo especificados por el servidor.
- La configuración es general para el movimiento de este cliente: se puede utilizar mediante control manual, ruta de mapa y otros scripts. Cambiándolo temporalmente, mantiene el valor anterior y lo restablece después de la operación; no cambie un modo al mismo tiempo de varios procedimientos.
- Los pasos giratorios y desviados son diferentes de los movimientos normales. La confirmación del servidor, los retrasos en la comunicación y los obstáculos pueden aumentar el tiempo real. El cliente no envía una serie de pasos acelerados para ponerse al día con los fotogramas faltantes.
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.
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.GetRunUnMountTimer();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parámetros y flujo de ejecución:
- UO.GetRunUnmountTimer() se llama sin argumentos. delayMs - intervalo de carrera a pie; otros modos no se miden aquí.
var delayMs = UO.GetRunUnMountTimer();
UO.Print("Movement delay, ms: " + Convert.ToString(delayMs));Parámetros y flujo de ejecución:
- pasos=5 es el número de pasos a evaluar, no un parámetro de comando. La multiplicación da sólo la contribución de los retrasos configurados; no es una promesa de hora de llegada ni de tiempo de espera de ruta.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var steps = 5;
var delayMs = UO.GetRunUnMountTimer();
var estimateMs = steps * delayMs;
UO.Print("Step-delay budget, ms: " + Convert.ToString(estimateMs));
return null;
}Parámetros y flujo de ejecución:
- anterior se compara con 200 ms. Se establece el intervalo estándar, se guardan los otros tres modos. El personaje no se mueve más allá del desafío en sí.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
var previous = UO.GetRunUnMountTimer();
if (Truth(previous > 200))
{
UO.SetRunUnmountTimer(200);
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.GetWalkMountTimer();Muestra el intervalo configurado de un paso de marcha a caballo en milisegundos. Útil para comprobar el modo, estimar el tiempo y guardar la configuración antes de reducir la velocidad temporalmente.
No hay parámetros.
int de 200 a 2000 inclusive: intervalo configurado en milisegundos. El valor predeterminado es 200. Esta es la cantidad de veces, no true/false, no ID, ni la cantidad de celdas pasadas.
- El ajuste se aplica al modo de conducción. El valor estándar y mínimo permitido es 200 ms; el límite superior es 2000 ms. Los otros tres modos tienen configuraciones separadas.
- Este es el intervalo de movimiento local del personaje, no el ping, FPS, el tiempo de espera de búsqueda de ruta o la duración medida del paso del servidor. Aumentar el número ralentiza el movimiento; disminuir por debajo del intervalo estándar no acelera el envío de paquetes.
- El equipo en sí no comienza a moverse, no se monta en la montura y no cambia el modo de caminar/correr. El modo se selecciona mientras se conduce; El cliente también tiene en cuenta el modo de velocidad y el vuelo especificados por el servidor.
- La configuración es general para el movimiento de este cliente: se puede utilizar mediante control manual, ruta de mapa y otros scripts. Cambiándolo temporalmente, mantiene el valor anterior y lo restablece después de la operación; no cambie un modo al mismo tiempo de varios procedimientos.
- Los pasos giratorios y desviados son diferentes de los movimientos normales. La confirmación del servidor, los retrasos en la comunicación y los obstáculos pueden aumentar el tiempo real. El cliente no envía una serie de pasos acelerados para ponerse al día con los fotogramas faltantes.
- 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.
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.
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.GetWalkMountTimer();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parámetros y flujo de ejecución:
- UO.GetWalkMountTimer() se llama sin argumentos. delayMs — intervalo de caminata a caballo; otros modos no se miden aquí.
var delayMs = UO.GetWalkMountTimer();
UO.Print("Movement delay, ms: " + Convert.ToString(delayMs));Parámetros y flujo de ejecución:
- pasos=5 es el número de pasos a evaluar, no un parámetro de comando. La multiplicación da sólo la contribución de los retrasos configurados; no es una promesa de hora de llegada ni de tiempo de espera de ruta.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var steps = 5;
var delayMs = UO.GetWalkMountTimer();
var estimateMs = steps * delayMs;
UO.Print("Step-delay budget, ms: " + Convert.ToString(estimateMs));
return null;
}Parámetros y flujo de ejecución:
- anterior se compara con 200 ms. Se establece el intervalo estándar, se guardan los otros tres modos. El personaje no se mueve más allá del desafío en sí.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
var previous = UO.GetWalkMountTimer();
if (Truth(previous > 200))
{
UO.SetWalkMountTimer(200);
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.GetWalkUnmountTimer();Muestra el intervalo configurado de un paso de caminata en milisegundos. Útil para comprobar el modo, estimar el tiempo y guardar la configuración antes de reducir la velocidad temporalmente.
No hay parámetros.
int de 400 a 2000 inclusive: intervalo configurado en milisegundos. El valor predeterminado es 400. Esta es la cantidad de veces, no true/false, no ID, ni la cantidad de celdas pasadas.
- La configuración se aplica al modo caminar. El valor estándar y mínimo permitido es 400 ms; el límite superior es 2000 ms. Los otros tres modos tienen configuraciones separadas.
- Este es el intervalo de movimiento local del personaje, no el ping, FPS, el tiempo de espera de búsqueda de ruta o la duración medida del paso del servidor. Aumentar el número ralentiza el movimiento; disminuir por debajo del intervalo estándar no acelera el envío de paquetes.
- El equipo en sí no comienza a moverse, no se monta en la montura y no cambia el modo de caminar/correr. El modo se selecciona mientras se conduce; El cliente también tiene en cuenta el modo de velocidad y el vuelo especificados por el servidor.
- La configuración es general para el movimiento de este cliente: se puede utilizar mediante control manual, ruta de mapa y otros scripts. Cambiándolo temporalmente, mantiene el valor anterior y lo restablece después de la operación; no cambie un modo al mismo tiempo de varios procedimientos.
- Los pasos giratorios y desviados son diferentes de los movimientos normales. La confirmación del servidor, los retrasos en la comunicación y los obstáculos pueden aumentar el tiempo real. El cliente no envía una serie de pasos acelerados para ponerse al día con los fotogramas faltantes.
- 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.
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.
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.GetWalkUnmountTimer();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parámetros y flujo de ejecución:
- UO.GetWalkUnmountTimer() se llama sin argumentos. delayMs — intervalo de caminata; otros modos no se miden aquí.
var delayMs = UO.GetWalkUnmountTimer();
UO.Print("Movement delay, ms: " + Convert.ToString(delayMs));Parámetros y flujo de ejecución:
- pasos=5 es el número de pasos a evaluar, no un parámetro de comando. La multiplicación da sólo la contribución de los retrasos configurados; no es una promesa de hora de llegada ni de tiempo de espera de ruta.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var steps = 5;
var delayMs = UO.GetWalkUnmountTimer();
var estimateMs = steps * delayMs;
UO.Print("Step-delay budget, ms: " + Convert.ToString(estimateMs));
return null;
}Parámetros y flujo de ejecución:
- anterior se compara con 400 ms. Se establece el intervalo estándar, se guardan los otros tres modos. El personaje no se mueve más allá del desafío en sí.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
var previous = UO.GetWalkUnmountTimer();
if (Truth(previous > 400))
{
UO.SetWalkUnmountTimer(400);
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.IsMoving();Comprueba el movimiento de tu personaje.
No hay parámetros.
int bool (1/0): 1 - el Buscatrazos automático está activo o todavía hay pasos en la cola del personaje; 0: faltan ambos o el personaje no está cargado. Esto no es una confirmación del logro de una meta o del número de pasos.
El resultado del comando es una bandera numérica: 1 significa una condición cumplida, 0 significa una condición no cumplida. Después de var resultado = comando(...) verifique si (resultado! = 0) o si (resultado == 0). Guarde el resultado de una llamada: una llamada repetida puede realizar la acción nuevamente o leer el estado que ya cambió.
- 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.
- Estas son funciones de lectura: al asignar el resultado a una variable se guarda la instantánea. No cambia las características del personaje. Los nombres no distinguen entre mayúsculas y minúsculas; utilice exactamente el formulario que se muestra con el número requerido de argumentos.
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.
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.IsMoving();
UO.Print("IsMoving: " + Convert.ToString(result));Parámetros y flujo de ejecución:
- Los paréntesis vacíos dicen self. activo — número 1 o 0; El texto del mensaje sirve como ejemplo de procesamiento de sucursales.
- 1: el Buscatrazos automático está activo o todavía hay pasos en la cola del personaje; 0: faltan ambos o el personaje no está cargado. Esto no es una confirmación del logro de una meta o del número de pasos.
var active = UO.IsMoving();
if (Truth(active))
{
UO.Print("State is active");
}
else
{
UO.Print("State is inactive or unavailable");
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parámetros y flujo de ejecución:
- El comando no tiene argumento de objeto: incluso después de Exists(self), solo lee su propio estado.
- Exists(self) verifica la carga de trabajo del jugador por separado del indicador solicitado. El mundo puede cambiar entre cheques.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
if (Truth(UO.Exists("self")))
{
var state = UO.IsMoving();
UO.Print("State 1/0: " + Convert.ToString(state));
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parámetros y flujo de ejecución:
- Las dos llamadas sin argumentos dicen self; UO.Wait(500) - pausa de medio segundo.
- Se comparan dos instantáneas de banderas. Se pueden omitir las transiciones entre planos; no es una suscripción a todos los eventos del servidor.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
var before = UO.IsMoving();
await Delay(500);
var after = UO.IsMoving();
if (Truth(before != after))
{
UO.Print("State changed from " + Convert.ToString(before) + " to " + 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;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.IsRunning(object? arg0);Comprueba la bandera de ejecución en la última dirección conocida mobile.
-
id— Obligatorio serial/ID de un objeto específico: int, cadena hexadecimal o alias self, backpack, lasttarget, lastobject, lastcontainer, último estado, elemento de búsqueda, último cadáver o nombre AddObject. Esto no es graphic/type. El nombre no especificado se resuelve en 0; el comando no abre ningún objetivo nuevo. El argumento es necesario; para usted, pase self. -
ObjID— Obligatorio serial/ID de un objeto específico: int, cadena hexadecimal o alias self, backpack, lasttarget, lastobject, lastcontainer, último estado, elemento de búsqueda, último cadáver o nombre AddObject. Esto no es graphic/type. El nombre no especificado se resuelve en 0; el comando no abre ningún objetivo nuevo. El argumento es necesario; para usted, pase self. -
MobID— Obligatorio serial/ID de un objeto específico: int, cadena hexadecimal o alias self, backpack, lasttarget, lastobject, lastcontainer, último estado, elemento de búsqueda, último cadáver o nombre AddObject. Esto no es graphic/type. El nombre no especificado se resuelve en 0; el comando no abre ningún objetivo nuevo. El argumento es necesario; para usted, pase self.
int 1 - cargado mobile tiene el atributo Direction.Running. int 0: falta el atributo, el objeto no es mobile, desconocido o eliminado. La última bandera en marcha puede conservarse después de detenerse. Esta no es la actividad de la ruta, ni la velocidad ni el número de pasos restantes. Para mover self use Moving() también.
El resultado del comando es una bandera numérica: 1 significa una condición cumplida, 0 significa una condición no cumplida. Después de var resultado = comando(...) verifique si (resultado! = 0) o si (resultado == 0). Guarde el resultado de una llamada: una llamada repetida puede realizar la acción nuevamente o leer el estado que ya cambió.
- Se lee el modelo del cliente local; No hay solicitudes al servidor, ni esperas ni movimientos.
- El resultado se refiere al momento de la lectura. Después de UO.Wait u otra acción, el objeto y sus indicadores pueden cambiar.
- La última bandera en marcha puede conservarse después de detenerse. Esta no es la actividad de la ruta, ni la velocidad ni el número de pasos restantes. Para mover self también use Moving().
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.
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.IsRunning("self");
UO.Print("IsRunning: " + Convert.ToString(result));Parámetros y flujo de ejecución:
- El argumento self selecciona explícitamente su carácter. estado: 1/0 únicamente.
- La última bandera en marcha puede conservarse después de detenerse. Esta no es la actividad de la ruta, ni la velocidad ni el número de pasos restantes. Para mover self también use Moving().
var state = UO.IsRunning("self");
var moving = UO.Moving();
UO.Print("Running flag: " + Convert.ToString(state));
UO.Print("Self movement active: " + Convert.ToString(moving));Parámetros y flujo de ejecución:
- IsNpc excluye sujeto y objeto desconocido. El objetivo almacena un único serial en lugar de una referencia activa a un lasttarget cambiante.
- El resultado se refiere al campo Direction.Running. Los datos se actualizan solo después de que el cliente recibe el estado apropiado.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var target = UO.GetSerial("lasttarget");
if (Truth(UO.IsNPC(target)))
{
var state = UO.IsRunning(target);
UO.Print("Selected mobile state 1/0: " + Convert.ToString(state));
}
else
{
UO.Print("No loaded mobile selected");
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parámetros y flujo de ejecución:
- UO.Wait(500): pausa en milisegundos. Después, se comprueba por separado que mobile todavía existe.
- Se comparan dos fotografías. Es posible que se pierdan los cambios intermedios y esta no es una suscripción continua a los eventos del servidor.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
var target = UO.GetSerial("lasttarget");
if (Truth(UO.IsNPC(target)))
{
var before = UO.IsRunning(target);
await Delay(500);
if (Truth(UO.IsNPC(target)))
{
var after = UO.IsRunning(target);
if (Truth(before != after))
{
UO.Print("Flag changed: " + Convert.ToString(before) + " -> " + Convert.ToString(after));
}
}
else
{
UO.Print("Mobile left the local world");
}
}
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.LastStepQUsedDoor();
dynamic UO.LastStepQUsedDoor(object? arg0);Lee o cambia manualmente el indicador de intento de apertura de puerta del último comando StepQ.
-
value— Entero opcional. Exactamente este número se almacena con el argumento; sin argumento, se realiza la lectura.
int: marca guardada. El StepQ habitual lo restablece a 0 y, con moveOpenDoor habilitado, escribe el resultado TryOpenDoorForStep: 1 si se detecta un intento, 0 en caso contrario. El formulario manual permite otros números. Esto no es un serial de puerta ni una confirmación de su apertura.
- El cheque no lee el estado de la puerta del servidor. La llamada alternativa OpenDoor no cambia la marca cero.
- Si StepQ falla antes de tiempo debido a la conexión/resistencia, el restablecimiento aún no se realiza, por lo que el valor anterior puede permanecer.
- 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.
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.
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.LastStepQUsedDoor();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parámetros y flujo de ejecución:
- Sin argumentos, se lee el número almacenado.
- No lo use como ID para UseObject.
UO.Print(Convert.ToString(UO.LastStepQUsedDoor()));Parámetros y flujo de ejecución:
- value=0 borra la marca anterior. dirección=2 — E; ejecutar=false.
- El resultado de StepQ y la marca de la puerta tienen significados diferentes.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
UO.LastStepQUsedDoor(0);
var status = UO.StepQ(2, false);
UO.Print(Convert.ToString(UO.LastStepQUsedDoor()));
return null;
}Parámetros y flujo de ejecución:
- anterior: valor guardado.
- La recuperación manual no realiza ninguna acción en la puerta.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
var previous = UO.LastStepQUsedDoor();
UO.LastStepQUsedDoor(0);
UO.Print(Convert.ToString(UO.LastStepQUsedDoor()));
UO.LastStepQUsedDoor(previous);
return null;
}
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.Move();Lee si hay una ruta automática o pasos de personajes que aún no se han completado.
No hay parámetros.
int 1: Pathfinder está activo o los pasos permanecen en la cola de animación del personaje; 0: faltan ambos o el personaje no está cargado. Este no es el número de pasos, el resultado de alcanzar un objetivo anterior o una señal de mantener presionado el mouse.
El resultado del comando es una bandera numérica: 1 significa una condición cumplida, 0 significa una condición no cumplida. Después de var resultado = comando(...) verifique si (resultado! = 0) o si (resultado == 0). Guarde el resultado de una llamada: una llamada repetida puede realizar la acción nuevamente o leer el estado que ya cambió.
- El comando solo lee el estado. Si el resultado es distinto de cero, se actualiza el temporizador compatible TicksAnim. Los pasos solicitados por el mouse/teclas también se cuentan mientras permanecen en la cola.
- Para detener la ruta automática, utilice MoverStop. MoveOff controla otros pasos del teclado.
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.
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.Move();
UO.Print("Move: " + Convert.ToString(result));Parámetros y flujo de ejecución:
- No hay argumentos.
- 0 no prueba que se haya logrado el objetivo: la ruta podría haberse cancelado.
UO.Print("Movement active or queued: " + Convert.ToString(UO.Move()));Parámetros y flujo de ejecución:
- 100 espera más de 50 ms y establece el límite aproximado de 5 segundos.
- La realización de esta verificación no inicia ni detiene el movimiento.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var attempts = 0;
while (Truth(UO.Move()) && Truth(attempts < 100))
{
await Delay(50);
attempts = attempts + 1;
}
UO.Print("Still moving: " + Convert.ToString(UO.Move()));
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;Parámetros y flujo de ejecución:
- Move() comprueba la actividad, MoverStop() elimina la ruta.
- El servidor aún puede confirmar los paquetes ya enviados.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
if (Truth(UO.Move()))
{
UO.MoverStop();
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.MoveOff();Desactiva los pasos clave compatibles con PMove.
No hay parámetros.
void: sin valor de retorno. Llame en una línea separada; no es true/false ni el número de pasos.
- Cambia el indicador MoveEnabled en el estado de tiempo de ejecución. Este no es un bloqueo de caracteres universal: NewMoveXY, MoveXYZ, Step y el mouse no están controlados por esta bandera.
- MoveOff no detiene un Pathfinder que ya se está ejecutando; requiere MoverStop.
- 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.
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.
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.MoveOff");
UO.MoveOff();Parámetros y flujo de ejecución:
- No hay argumentos.
- La bandera PMove se cambia, sin valor de retorno.
UO.MoveOff();Parámetros y flujo de ejecución:
- MoveOn habilita pasos clave antes de PMove; MoveOff se apaga después de su finalización normal.
- Estos son comandos secuenciales; una bandera desactivada no significa una parada de emergencia para todos los procedimientos.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
UO.MoveOn();
UO.PMove(UO.GetX() + 1, UO.GetY());
UO.MoveOff();
return null;
}Parámetros y flujo de ejecución:
- Los dos equipos controlan diferentes mecanismos de movimiento.
- Move() lee la ruta automática; no lo considere una prueba de MoveEnabled.
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()
{
UO.MoveOff();
UO.MoverStop();
UO.Print(Convert.ToString(UO.Move()));
return null;
}
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.MoveOn();Habilita pasos clave PMove compatibles.
No hay parámetros.
void: sin valor de retorno. Llame en una línea separada; no es true/false ni el número de pasos.
- Cambia el indicador MoveEnabled en el estado de tiempo de ejecución. Este no es un bloqueo de caracteres universal: NewMoveXY, MoveXYZ, Step y el mouse no están controlados por esta bandera.
- MoveOff no detiene un Pathfinder que ya se está ejecutando; requiere MoverStop.
- 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.
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.
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.MoveOn");
UO.MoveOn();Parámetros y flujo de ejecución:
- No hay argumentos.
- La bandera PMove se cambia, sin valor de retorno.
UO.MoveOn();Parámetros y flujo de ejecución:
- MoveOn habilita pasos clave antes de PMove; MoveOff se apaga después de su finalización normal.
- Estos son comandos secuenciales; una bandera desactivada no significa una parada de emergencia para todos los procedimientos.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
UO.MoveOn();
UO.PMove(UO.GetX() + 1, UO.GetY());
UO.MoveOff();
return null;
}Parámetros y flujo de ejecución:
- MoveOn habilita pasos clave de PMove compatibles y no devuelve un valor. El resultado del movimiento se comprueba mediante coordenadas; MoveOn no controla todos los modos de movimiento.
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()
{
UO.MoveOn();
int destinationX = UO.GetX() + 1;
int destinationY = UO.GetY();
UO.PMove(destinationX, destinationY);
UO.Print($"Reached requested tile: {UO.GetX() == destinationX && UO.GetY() == destinationY}");
return null;
}
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.MoveXY(object? arg0, object? arg1, object? arg2, object? arg3, object? arg4);Mueve el personaje a X/Y con cinco parámetros requeridos y espera el resultado.
-
Xdst— Coordenada mundial X del destino, 0...65535. Esto no es serial ni una posición dentro de una encía. -
x— Coordenada mundial X del destino, 0...65535. Esto no es serial ni una posición dentro de una encía. -
Ydst— Coordenada mundial Y de destino, 0...65535. -
y— Coordenada mundial Y de destino, 0...65535. -
Optimized- true - modo normal de buscar y comprobar el camino a seguir; false: heurística reducida y verificación del paso más cercano. false no desactiva la evitación de obstáculos. -
Accuracy— Tolerancia para X e Y en las celdas: ambas desviaciones deben encajar dentro de ella. El valor está limitado al rango 0..20; 0 requiere X/Y preciso. -
Running- true/1 - ejecutar solicitud, false/0 - paso. Persisten los retrasos en el movimiento del servidor; No es un multiplicador de velocidad.
int 1: al final de la verificación, el personaje se encuentra en la tolerancia dada X/Y/Z, incluso cuando ya estaba allí antes del desafío. int 0: coordenadas no válidas, error de lanzamiento, punto no alcanzado o condición de parada activada. No es la cantidad de pasos o serial; En caso de cancelación de emergencia, el procedimiento se cancela en lugar de volver a la normalidad 0.
El resultado del comando es una bandera numérica: 1 significa una condición cumplida, 0 significa una condición no cumplida. Después de var resultado = comando(...) verifique si (resultado! = 0) o si (resultado == 0). Guarde el resultado de una llamada: una llamada repetida puede realizar la acción nuevamente o leer el estado que ya cambió.
- La ruta A* completa se construye antes del primer paso, en porciones cortas entre actualizaciones del cliente. Cuando Optimizado=true se marcan las siguientes celdas 4 de la ruta; cuando false es el paso más cercano. Se trata de una comprobación de la ruta ya calculada, y no de la distancia de toda la ruta ni de los controles deslizantes de desvío al mover el ratón.
- La falla del servidor DenyWalk o un nuevo obstáculo solicita un nuevo cálculo desde la posición actual después de completar la cola de pasos. El número de repeticiones y la frecuencia de recálculo son limitados; ningún camino puede finalizar el movimiento con 0.
- El recorrido pertenece al procedimiento que lo inició: su parada de emergencia anula el recorrido automático restante. Si otra carrera o usuario ya ha reemplazado la ruta, cancelar el propietario anterior no afecta la nueva ruta. Los pasos ya enviados no se recuperan.
- SetBadLocation y SetBadObject se utilizan como una instantánea de las prohibiciones del tiempo de ejecución actual cuando se inicia la ruta. Se guardan durante su recálculo interno. Cambiar o borrar listas afecta a la siguiente ruta, en lugar de sobrescribir una que ya está en progreso.
- Después de aceptar la solicitud, la llamada espera en el hilo del script. La búsqueda inicial y el recálculo se realizan en la secuencia del juego en fragmentos: un máximo de 32 expansión de nodo y un presupuesto flexible de aproximadamente 1 ms por fragmento. Un control celular complejo o una lectura de tarjeta pueden exceder este presupuesto. Entre porciones, el cliente continúa actualizándose; el límite total de búsqueda sigue siendo 10000 nodos.
- El tiempo de espera se cuenta después de que se acepta la solicitud e incluye partes posteriores de búsqueda y recálculo. stopOnStuck no considera que una búsqueda en ejecución sea un carácter atascado; Una vez finalizada la planificación, no se vuelven a tener en cuenta cambios de posición. El 1/0 final verifica las coordenadas reales, no solo la preparación del camino.
- El resultado tiene en cuenta la posición local del cliente; La corrección posterior del servidor aún es posible. Ejecutar comandos de movimiento competitivos de diferentes rutinas cambia la ruta general del personaje.
- Las configuraciones moveCheckStamina, moveExitOnDisconnect, moveOpenDoor, moveThroughCorner, moveThroughNPC, moveHeuristicMult, moveTurnCost y moveBetweenTwoCorners afectan el rendimiento. avoidMobiles/openDoors explícito anula los valores correspondientes para esta llamada.
- El resultado 0 no indica la causa exacta. Verifique las coordenadas, la conexión, la resistencia y el registro; No repitas el movimiento infinitamente sin UO.Wait y un límite de intentos.
- El objetivo Z se toma cuando se llama, tolerancia Z=255. Para restricciones adicionales, utilice NewMoveXY; para seleccionar la altura - MoveXYZ.
- El puente principal registra el número de solicitud, las instancias de jugador/Pathfinder/mapa y el índice del mapa. Una nueva solicitud, cambio de contexto o rechazo final da 0; la verificación se repite después de leer las coordenadas y la última devolución de llamada. El tiempo de espera, maxSteps y callback=0 solo detienen la solicitud guardada, no una nueva ruta externa. El Bloqueado Temporal, mientras la recuperación sigue activa, no pierde la posesión: la espera continúa. Para el puente heredado externo sin IApiMovementOwnershipBridge, se conserva el mecanismo compatible anterior.
- El Pathfinder general almacena hasta 8 prohibiciones direccionales X/Y/Z temporales durante 2000 ms, solo en caso de movimiento rechazado de la solicitud activa correspondiente. La rotación, la secuencia desconocida, la resincronización y la solicitud antigua/extraña no crean dicha prohibición. Una nueva solicitud externa y la pérdida del contexto del mapa/jugador los borra. La búsqueda de geometría cargada intenta omitir la transición; es no conocer todos los obstáculos del servidor. Sin cambiar el X/Y/Z del reproductor, se permiten hasta 8 recálculos internos con una pausa de al menos 40 ms. No existe un camino completo o este presupuesto se ha agotado: la ruta termina. Luego, la tarea coordinada se completa después de procesar los pasos enviados; mobile-Follow puede intentarlo nuevamente debido a su retraso.
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.
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.MoveXY(UO.GetX() + 2, UO.GetY(), true, 0, false);
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Parámetros y flujo de ejecución:
- Xdst: dos celdas al este; Ydst no cambia.
- Optimizado=true, Precisión=0, En ejecución=false. La llamada devuelve el resultado cuando se completa.
var ok = UO.MoveXY(UO.GetX() + 2, UO.GetY(), true, 0, false);
UO.Print(Convert.ToString(ok));Parámetros y flujo de ejecución:
- Xdst/Ydst se leen del objeto seleccionado; debe ser un objeto del mundo, no un objeto dentro del contenedor.
- Precisión=1 te permite acercarte; Corriendo=true. Las alturas no se limitan a este desafío.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
if (Truth(UO.Exists("lasttarget")))
{
var ok = UO.MoveXY(UO.GetX("lasttarget"), UO.GetY("lasttarget"), true, 1, true);
UO.Print("Approach result: " + Convert.ToString(ok));
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parámetros y flujo de ejecución:
- Reemplace el objetivo 1445/1690 por el suyo propio. El umbral de resistencia se establece mediante una configuración separada, no el sexto parámetro MoveXY.
- Después de una devolución normal, se restaura el valor original. Si se produce una interrupción, no se ejecutan más líneas.
Intervalo mínimo de paso: caminar - caminar 400 ms, correr 200 ms; montar a caballo - caminar 200 ms, correr 100 ms.
Estos son límites de cliente estándar, no configuraciones definidas automáticamente para su fragmento. La velocidad del servidor y los modos de vuelo se cuentan por separado. Los temporizadores de guiones pueden ralentizar el movimiento, pero no reducen estos límites.
Los pasos, las rutas, Follow, los controles del mouse/teclas y el mapa utilizan la cola compartida del personaje. Reemplazar la ruta, girar o ajustar la posición por parte del servidor no cancela la pausa restante después de la solicitud del paso. Después del retraso, no hay una ráfaga rápida para compensar los fotogramas perdidos. La espera de confirmación, los obstáculos y la mala comunicación pueden ralentizar el movimiento.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
var previous = UO.moveCheckStamina();
UO.moveCheckStamina(15);
var ok = UO.MoveXY(1445, 1690, true, 0, false);
UO.moveCheckStamina(previous);
UO.Print(Convert.ToString(ok));
return null;
}
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.MoveXYZ(object? arg0, object? arg1, object? arg2, object? arg3, object? arg4, object? arg5);
int UO.MoveXYZ(object? arg0, object? arg1, object? arg2, object? arg3, object? arg4, object? arg5, object? arg6);
int UO.MoveXYZ(object? arg0, object? arg1, object? arg2, object? arg3, object? arg4, object? arg5, object? arg6, object? arg7);
int UO.MoveXYZ(object? arg0, object? arg1, object? arg2, object? arg3, object? arg4, object? arg5, object? arg6, object? arg7, object? arg8);
int UO.MoveXYZ(object? arg0, object? arg1, object? arg2, object? arg3, object? arg4, object? arg5, object? arg6, object? arg7, object? arg8, object? arg9);Mueve el personaje a un punto del mundo con tolerancias horizontales y verticales separadas.
-
x- Requerido int: coordenada mundial del destino X, 0..65535, en el mapa actual. No la coordenada gump. -
y- Requerido int: coordenada mundial del destino Y, 0..65535, en el mapa actual. -
z- Obligatorio int: altitud mundial objetivo -128..127. Ésta es la altura de la superficie, no el número del piso. -
accuracyXY- Obligatorio int. Tolerancia para X y Y en celdas: ambas desviaciones deben encajar dentro de ella. El valor está limitado al rango 0..20; 0 requiere X/Y preciso. -
accuracyZ- Obligatorio int. Tolerancia de altura: abs(real Z - requerido Z), limitado a 0..255. El cero requiere una altitud precisa; 255 prácticamente desactiva la limitación de Z. -
running: indicador booleano obligatorio. true/1: ejecutar solicitud, false/0: paso. Persisten los retrasos en el movimiento del servidor; No es un multiplicador de velocidad. -
timeout— Límite de espera opcional en milisegundos; un argumento faltante, 0 y un valor negativo indican la ausencia de este límite adicional. La cuenta regresiva comienza después de que se acepta la ruta para su ejecución; Este no es un límite estricto en la duración de toda la llamada junto con la preparación de la ruta. -
maxSteps: límite opcional de cambios de posición observados, no de paquetes de red. 0/negativo/ausente - sin este límite. Puede haber varios pasos entre encuestas, por lo que este no es un contador de celdas preciso. -
avoidMobiles— Bandera opcional: true prohíbe pasar por los caracteres que se tienen en cuenta; false permite el intento. Sin argumento, se utiliza moveThroughNPC. El servidor aún puede denegar el acceso. -
openDoors— Bandera opcional para abrir puertas en el camino. Sin argumento, se utiliza moveOpenDoor; true no proporciona acceso a puertas cerradas.
int 1: al final de la verificación, el personaje se encuentra en la tolerancia dada X/Y/Z, incluso cuando ya estaba allí antes del desafío. int 0: coordenadas no válidas, error de lanzamiento, punto no alcanzado o condición de parada activada. No es la cantidad de pasos o serial; En caso de cancelación de emergencia, el procedimiento se cancela en lugar de volver a la normalidad 0.
El resultado del comando es una bandera numérica: 1 significa una condición cumplida, 0 significa una condición no cumplida. Después de var resultado = comando(...) verifique si (resultado! = 0) o si (resultado == 0). Guarde el resultado de una llamada: una llamada repetida puede realizar la acción nuevamente o leer el estado que ya cambió.
- Cómo funciona, paso 1: verifica coordenadas, conexión configurada y condiciones de resistencia. Si el personaje ya está dentro de accuracyXY y accuracyZ, regresa inmediatamente a 1 sin una nueva ruta.
- Paso 2: construye una ruta en el mapa actual teniendo en cuenta la altura de la superficie, los obstáculos y las condiciones de paso seleccionadas. El modo optimizado está habilitado dentro del comando aquí; No es necesario pasar dicho parámetro a MoveXYZ.
- Paso 3: comienza a caminar o correr por la ruta y espera el resultado en el procedimiento actual. La línea después de la llamada se ejecuta una vez completada; la interfaz del cliente continúa funcionando.
- Paso 4: Si un paso falla o aparece un nuevo obstáculo, el cliente puede recalcular la ruta desde la posición actual. Los intentos son limitados. Cuando ocurre un tiempo de espera o se alcanza el límite de movimientos observables más allá del objetivo, el movimiento se detiene con 0.
- Paso 5: Una vez finalizado el movimiento, compara el X/Y/Z real del cliente con el objetivo. Se requieren ambos abs(X-x)<=accuracyXY, abs(Y-y)<=accuracyXY y abs(Z-z)<=accuracyZ. Por ejemplo, para el objetivo 1279/540/20 con tolerancias 1 y 2 X=1278..1280, Y=539..541 son adecuados, Z=18..22.
- La forma mínima contiene seis argumentos: UO.MoveXYZ(1279,540,20,1,2,true). Se agregan argumentos adicionales a la derecha del tiempo de espera del orden, maxSteps, avoidMobiles, openDoors. Para concretar openDoors también se deben pasar las posiciones anteriores; No se admiten espacios en blanco entre comas.
- Diferencia con NewMoveXY: MoveXYZ toma la altura del objetivo como tercer argumento. NewMoveXY tiene un tercer argumento de Optimizado; No puedes transferir altitud allí. MoveXYZ no tiene devolución de llamada en este tiempo de ejecución.
- El recorrido pertenece al procedimiento que lo inició: su parada de emergencia anula el recorrido automático restante. Si otra carrera o usuario ya ha reemplazado la ruta, cancelar el propietario anterior no afecta la nueva ruta. Los pasos ya enviados no se recuperan.
- SetBadLocation y SetBadObject se utilizan como una instantánea de las prohibiciones del tiempo de ejecución actual cuando se inicia la ruta. Se guardan durante su recálculo interno. Cambiar o borrar listas afecta a la siguiente ruta, en lugar de sobrescribir una que ya está en progreso.
- Después de aceptar la solicitud, la llamada espera en el hilo del script. La búsqueda inicial y el recálculo se realizan en la secuencia del juego en fragmentos: un máximo de 32 expansión de nodo y un presupuesto flexible de aproximadamente 1 ms por fragmento. Un control celular complejo o una lectura de tarjeta pueden exceder este presupuesto. Entre porciones, el cliente continúa actualizándose; el límite total de búsqueda sigue siendo 10000 nodos.
- El tiempo de espera se cuenta después de que se acepta la solicitud e incluye partes posteriores de búsqueda y recálculo. stopOnStuck no considera que una búsqueda en ejecución sea un carácter atascado; Una vez finalizada la planificación, no se vuelven a tener en cuenta cambios de posición. El 1/0 final verifica las coordenadas reales, no solo la preparación del camino.
- El resultado tiene en cuenta la posición local del cliente; La corrección posterior del servidor aún es posible. Ejecutar comandos de movimiento competitivos de diferentes rutinas cambia la ruta general del personaje.
- Las configuraciones moveCheckStamina, moveExitOnDisconnect, moveOpenDoor, moveThroughCorner, moveThroughNPC, moveHeuristicMult, moveTurnCost y moveBetweenTwoCorners afectan el rendimiento. avoidMobiles/openDoors explícito anula los valores correspondientes para esta llamada.
- El resultado 0 no indica la causa exacta. Verifique las coordenadas, la conexión, la resistencia y el registro; No repitas el movimiento infinitamente sin UO.Wait y un límite de intentos.
- El puente principal registra el número de solicitud, las instancias de jugador/Pathfinder/mapa y el índice del mapa. Una nueva solicitud, cambio de contexto o rechazo final da 0; la verificación se repite después de leer las coordenadas y la última devolución de llamada. El tiempo de espera, maxSteps y callback=0 solo detienen la solicitud guardada, no una nueva ruta externa. El Bloqueado Temporal, mientras la recuperación sigue activa, no pierde la posesión: la espera continúa. Para el puente heredado externo sin IApiMovementOwnershipBridge, se conserva el mecanismo compatible anterior.
- El Pathfinder general almacena hasta 8 prohibiciones direccionales X/Y/Z temporales durante 2000 ms, solo en caso de movimiento rechazado de la solicitud activa correspondiente. La rotación, la secuencia desconocida, la resincronización y la solicitud antigua/extraña no crean dicha prohibición. Una nueva solicitud externa y la pérdida del contexto del mapa/jugador los borra. La búsqueda de geometría cargada intenta omitir la transición; es no conocer todos los obstáculos del servidor. Sin cambiar el X/Y/Z del reproductor, se permiten hasta 8 recálculos internos con una pausa de al menos 40 ms. No existe un camino completo o este presupuesto se ha agotado: la ruta termina. Luego, la tarea coordinada se completa después de procesar los pasos enviados; mobile-Follow puede intentarlo nuevamente debido a su retraso.
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.
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.MoveXYZ(UO.GetX() + 1, UO.GetY(), UO.GetZ(), 0, 0, false);
UO.Print("MoveXYZ: " + Convert.ToString(result));Parámetros y flujo de ejecución:
- x/y/z es el punto objetivo. accuracyXY=0 y accuracyZ=0 requieren una posición precisa.
- corriendo=false - caminando. Si la superficie adyacente tiene una altura diferente, el resultado puede ser 0.
var ok = UO.MoveXYZ(UO.GetX() + 1, UO.GetY(), UO.GetZ(), 0, 0, false);
UO.Print(Convert.ToString(ok));Parámetros y flujo de ejecución:
- Preparación: el personaje debe estar en el juego y el punto debe existir en el mapa actual. 1279/540/20 son coordenadas de entrenamiento: reemplácelas con su punto disponible, incluida la altura real de la superficie.
-
- destinationX=1279 es el primer argumento, la coordenada mundial X del objetivo.
-
- destinationY=540 es el segundo argumento, la coordenada mundial Y del objetivo.
-
- destinationZ=20 - tercer argumento, altura. El equipo debe encontrar un pasaje o escalera; el valor 20 por sí solo no se transfiere al suelo.
-
- accuracyXY=1 le permite terminar dentro de una celda a lo largo de cada coordenada horizontal. También es adecuada la celda contigua en diagonal.
-
- accuracyZ=2 permite alturas desde 18 hasta 22 inclusive. Una coincidencia X/Y en otra planta no es suficiente para tener éxito.
-
- running=true solicitudes en ejecución. Para caminar, reemplace true con false.
-
- timeout=8000 limita la espera después de que comienza la ruta a ocho segundos. Pasado este tiempo, mientras el movimiento aún está en curso, el comando lo detiene y retorna 0.
-
- maxSteps=100 limita el número de cambios de posición observados. Este no es el número exacto de cuadrados atravesados; Pueden ocurrir múltiples pasos entre sondeos.
-
- avoidMobiles=true prohíbe pasar por los caracteres tenidos en cuenta al calcular la ruta.
-
- openDoors=true permite intentos de abrir puertas en el camino. Esta bandera no evita una puerta cerrada ni las restricciones del servidor.
- alcanzado recibe int 1 o 0 después de que finaliza la llamada. si se alcanza == 1 ejecuta la rama exitosa; otra cosa maneja el fracaso para lograr el objetivo sin repetir interminablemente la orden.
- La última línea imprime el X/Y/Z actual para su verificación. Si el procedimiento se cancela, no se ejecutan más líneas, incluida esta salida.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var destinationX = 1279;
var destinationY = 540;
var destinationZ = 20;
var accuracyXY = 1;
var accuracyZ = 2;
dynamic running = true;
var timeout = 8000;
var maxSteps = 100;
dynamic avoidMobiles = true;
dynamic openDoors = true;
var reached = UO.MoveXYZ(destinationX, destinationY, destinationZ, accuracyXY, accuracyZ, running, timeout, maxSteps, avoidMobiles, openDoors);
if (Truth(reached == 1))
{
UO.Print("Destination reached");
}
else
{
UO.Print("Destination not reached; check the path and limits");
}
UO.Print("Position: " + Convert.ToString(UO.GetX()) + "," + Convert.ToString(UO.GetY()) + "," + Convert.ToString(UO.GetZ()));
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parámetros y flujo de ejecución:
- x/y/z=1445/1690/0; accuracyXY=1, accuracyZ=3; running=true.
- timeout=5000, maxSteps=60 de desplazamientos observados, avoidMobiles=true y openDoors=false.
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 ok = UO.MoveXYZ(1445, 1690, 0, 1, 3, true, 5000, 60, true, false);
UO.Print("Result: " + Convert.ToString(ok));
return null;
}
}Parámetros y flujo de ejecución:
- Las líneas con # son comentarios C#: se guardan durante la copia y no se ejecutan. El ejemplo contiene las dos partes necesarias: la función GoToPoint y el procedimiento ejecutable Main.
- Los seis parámetros GoToPoint se pasan a MoveXYZ sin modificaciones. Se especifican cuatro parámetros adicionales dentro de la función: 8000 ms, 100 cambios de posición observados, recorrido de caracteres y apertura de puerta.
- Para este propósito son adecuados 1279/540/20 con tolerancias 1/2 X=1278..1280, Y=539..541, Z=18..22. Un punto a otra altitud más allá de 18...22 no se considera alcanzado.
- Esta es una envoltura del comando real, y no una segunda implementación de búsqueda de rutas en el script. No llama a un GetPathArray adicional y no activa reintentos interminables. Si no se logra, el procedimiento de llamada recibe 0 y elige acciones adicionales.
Intervalo mínimo de paso: caminar - caminar 400 ms, correr 200 ms; montar a caballo - caminar 200 ms, correr 100 ms.
Estos son límites de cliente estándar, no configuraciones definidas automáticamente para su fragmento. La velocidad del servidor y los modos de vuelo se cuentan por separado. Los temporizadores de guiones pueden ralentizar el movimiento, pero no reducen estos límites.
Los pasos, las rutas, Follow, los controles del mouse/teclas y el mapa utilizan la cola compartida del personaje. Reemplazar la ruta, girar o ajustar la posición por parte del servidor no cancela la pausa restante después de la solicitud del paso. Después del retraso, no hay una ráfaga rápida para compensar los fotogramas perdidos. La espera de confirmación, los obstáculos y la mala comunicación pueden ralentizar el movimiento.
var reached = GoToPoint(1279, 540, 20, 1, 2, true);
if (Truth(Truth(reached) == true))
{
UO.Print("Destination reached");
}
else
{
UO.Print("Destination not reached");
}
dynamic GoToPoint(dynamic x, dynamic y, dynamic z, dynamic accuracyXY, dynamic accuracyZ, dynamic running)
{
var timeout = 8000;
var maxSteps = 100;
dynamic avoidMobiles = true;
dynamic openDoors = true;
var reached = UO.MoveXYZ(x, y, z, accuracyXY, accuracyZ, running, timeout, maxSteps, avoidMobiles, openDoors);
return reached;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.MoverStop();Detiene la ruta automática de Pathfinder.
No hay parámetros.
void: sin valor de retorno. Llame en una línea separada; no es true/false ni el número de pasos.
- Elimina el movimiento automático local. Los pasos ya enviados y las confirmaciones del servidor no se recuperan.
- Esto no es TerminateAll: la ejecución de las líneas de script restantes y otros procedimientos continúa.
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.
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.MoverStop");
UO.MoverStop();Parámetros y flujo de ejecución:
- No hay argumentos.
- El comando no devuelve un código de éxito.
UO.MoverStop();Parámetros y flujo de ejecución:
- Move() lee el movimiento automático.
- Print — mensaje de script local; No es una confirmación del servidor.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
if (Truth(UO.Move()))
{
UO.MoverStop();
UO.Print("Route stopped");
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parámetros y flujo de ejecución:
- UO.Wait=100 ms permite al cliente procesar los siguientes eventos.
- Después de detenerse, las coordenadas se leen por separado; el retraso no garantiza la recepción de todos los acuses de recibo de la red.
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()
{
UO.MoverStop();
await Delay(100);
UO.Print(Convert.ToString(UO.GetX()) + "," + Convert.ToString(UO.GetY()));
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.Moving();Comprueba el movimiento de tu personaje.
No hay parámetros.
int bool (1/0): 1 - el Buscatrazos automático está activo o todavía hay pasos en la cola del personaje; 0: faltan ambos o el personaje no está cargado. Esto no es una confirmación del logro de una meta o del número de pasos.
El resultado del comando es una bandera numérica: 1 significa una condición cumplida, 0 significa una condición no cumplida. Después de var resultado = comando(...) verifique si (resultado! = 0) o si (resultado == 0). Guarde el resultado de una llamada: una llamada repetida puede realizar la acción nuevamente o leer el estado que ya cambió.
- 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.
- Estas son funciones de lectura: al asignar el resultado a una variable se guarda la instantánea. No cambia las características del personaje. Los nombres no distinguen entre mayúsculas y minúsculas; utilice exactamente el formulario que se muestra con el número requerido de argumentos.
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.
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.Moving();
UO.Print("Moving: " + Convert.ToString(result));Parámetros y flujo de ejecución:
- Los paréntesis vacíos dicen self. activo — número 1 o 0; El texto del mensaje sirve como ejemplo de procesamiento de sucursales.
- 1: el Buscatrazos automático está activo o todavía hay pasos en la cola del personaje; 0: faltan ambos o el personaje no está cargado. Esto no es una confirmación del logro de una meta o del número de pasos.
var active = UO.Moving();
if (Truth(active))
{
UO.Print("State is active");
}
else
{
UO.Print("State is inactive or unavailable");
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parámetros y flujo de ejecución:
- El comando no tiene argumento de objeto: incluso después de Exists(self), solo lee su propio estado.
- Exists(self) verifica la carga de trabajo del jugador por separado del indicador solicitado. El mundo puede cambiar entre cheques.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
if (Truth(UO.Exists("self")))
{
var state = UO.Moving();
UO.Print("State 1/0: " + Convert.ToString(state));
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parámetros y flujo de ejecución:
- Las dos llamadas sin argumentos dicen self; UO.Wait(500) - pausa de medio segundo.
- Se comparan dos instantáneas de banderas. Se pueden omitir las transiciones entre planos; no es una suscripción a todos los eventos del servidor.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
var before = UO.Moving();
await Delay(500);
var after = UO.Moving();
if (Truth(before != after))
{
UO.Print("State changed from " + Convert.ToString(before) + " to " + 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;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.NewMoveXY(object? arg0, object? arg1, object? arg2, object? arg3, object? arg4);
int UO.NewMoveXY(object? arg0, object? arg1, object? arg2, object? arg3, object? arg4, object? arg5);
int UO.NewMoveXY(object? arg0, object? arg1, object? arg2, object? arg3, object? arg4, object? arg5, object? arg6);
int UO.NewMoveXY(object? arg0, object? arg1, object? arg2, object? arg3, object? arg4, object? arg5, object? arg6, object? arg7);
int UO.NewMoveXY(object? arg0, object? arg1, object? arg2, object? arg3, object? arg4, object? arg5, object? arg6, object? arg7, object? arg8);
int UO.NewMoveXY(object? arg0, object? arg1, object? arg2, object? arg3, object? arg4, object? arg5, object? arg6, object? arg7, object? arg8, object? arg9);
int UO.NewMoveXY(object? arg0, object? arg1, object? arg2, object? arg3, object? arg4, object? arg5, object? arg6, object? arg7, object? arg8, object? arg9, object? arg10);
int UO.NewMoveXY(object? arg0, object? arg1, object? arg2, object? arg3, object? arg4, object? arg5, object? arg6, object? arg7, object? arg8, object? arg9, object? arg10, object? arg11);
int UO.NewMoveXY(object? arg0, object? arg1, object? arg2, object? arg3, object? arg4, object? arg5, object? arg6, object? arg7, object? arg8, object? arg9, object? arg10, object? arg11, object? arg12);Mueve el personaje a X/Y, espera el final y comprueba el logro del objetivo; admite restricciones adicionales y devoluciones de llamadas.
-
Xdst— Coordenada mundial X del destino, 0...65535. Esto no es serial ni una posición dentro de una encía. -
x— Coordenada mundial X del destino, 0...65535. Esto no es serial ni una posición dentro de una encía. -
Ydst— Coordenada mundial Y de destino, 0...65535. -
y— Coordenada mundial Y de destino, 0...65535. -
Optimized- true - modo normal de buscar y comprobar el camino a seguir; false: heurística reducida y verificación del paso más cercano. false no desactiva la evitación de obstáculos. -
Accuracy— Tolerancia para X e Y en las celdas: ambas desviaciones deben encajar dentro de ella. El valor está limitado al rango 0..20; 0 requiere X/Y preciso. -
Running- true/1 - ejecutar solicitud, false/0 - paso. Persisten los retrasos en el movimiento del servidor; No es un multiplicador de velocidad. -
timeout— Límite de espera opcional en milisegundos; un argumento faltante, 0 y un valor negativo indican la ausencia de este límite adicional. -
maxSteps: límite opcional de cambios de posición observados, no de paquetes de red. 0/negativo/ausente - sin este límite. Puede haber varios pasos entre encuestas, por lo que este no es un contador de celdas preciso. -
maxDistance: límite opcional en la distancia inicial máxima (abs(dx),abs(dy)) al objetivo. 0/ausencia lo desactiva. Esta no es la desviación permitida durante el recorrido ni la longitud del camino encontrado. -
AccuracyZ— Tolerancia de altura: abs(Z real - Z requerida), limitada por 0...255. El cero requiere una altitud precisa; 255 esencialmente desactiva el límite Z. Para NewMoveXY la Z objetivo es igual a la Z del personaje cuando es convocado; La tolerancia predeterminada es 255. -
avoidMobiles— Bandera opcional: true prohíbe pasar por los caracteres que se tienen en cuenta; false permite el intento. Sin argumento, se utiliza moveThroughNPC. El servidor aún puede denegar el acceso. -
openDoors— Bandera opcional para abrir puertas en el camino. Sin argumento, se utiliza moveOpenDoor; true no proporciona acceso a puertas cerradas. -
stopOnStuck- true completa el movimiento con 0, si después de planificar aproximadamente 1000 ms X/Y/Z no han cambiado. Las partes de búsqueda activa y recálculo reinician este temporizador; el tiempo de espera separado continúa funcionando. El valor predeterminado es false.
int 1: al final de la verificación, el personaje se encuentra en la tolerancia dada X/Y/Z, incluso cuando ya estaba allí antes del desafío. int 0: coordenadas no válidas, error de lanzamiento, punto no alcanzado o condición de parada activada. No es la cantidad de pasos o serial; En caso de cancelación de emergencia, el procedimiento se cancela en lugar de volver a la normalidad 0.
El resultado del comando es una bandera numérica: 1 significa una condición cumplida, 0 significa una condición no cumplida. Después de var resultado = comando(...) verifique si (resultado! = 0) o si (resultado == 0). Guarde el resultado de una llamada: una llamada repetida puede realizar la acción nuevamente o leer el estado que ya cambió.
- La ruta A* completa se construye antes del primer paso, en porciones cortas entre actualizaciones del cliente. Cuando Optimizado=true se marcan las siguientes celdas 4 de la ruta; cuando false es el paso más cercano. Se trata de una comprobación de la ruta ya calculada, y no de la distancia de toda la ruta ni de los controles deslizantes de desvío al mover el ratón.
- La falla del servidor DenyWalk o un nuevo obstáculo solicita un nuevo cálculo desde la posición actual después de completar la cola de pasos. El número de repeticiones y la frecuencia de recálculo son limitados; ningún camino puede finalizar el movimiento con 0.
- El recorrido pertenece al procedimiento que lo inició: su parada de emergencia anula el recorrido automático restante. Si otra carrera o usuario ya ha reemplazado la ruta, cancelar el propietario anterior no afecta la nueva ruta. Los pasos ya enviados no se recuperan.
- SetBadLocation y SetBadObject se utilizan como una instantánea de las prohibiciones del tiempo de ejecución actual cuando se inicia la ruta. Se guardan durante su recálculo interno. Cambiar o borrar listas afecta a la siguiente ruta, en lugar de sobrescribir una que ya está en progreso.
- Después de aceptar la solicitud, la llamada espera en el hilo del script. La búsqueda inicial y el recálculo se realizan en la secuencia del juego en fragmentos: un máximo de 32 expansión de nodo y un presupuesto flexible de aproximadamente 1 ms por fragmento. Un control celular complejo o una lectura de tarjeta pueden exceder este presupuesto. Entre porciones, el cliente continúa actualizándose; el límite total de búsqueda sigue siendo 10000 nodos.
- El tiempo de espera se cuenta después de que se acepta la solicitud e incluye partes posteriores de búsqueda y recálculo. stopOnStuck no considera que una búsqueda en ejecución sea un carácter atascado; Una vez finalizada la planificación, no se vuelven a tener en cuenta cambios de posición. El 1/0 final verifica las coordenadas reales, no solo la preparación del camino.
- El resultado tiene en cuenta la posición local del cliente; La corrección posterior del servidor aún es posible. Ejecutar comandos de movimiento competitivos de diferentes rutinas cambia la ruta general del personaje.
- Las configuraciones moveCheckStamina, moveExitOnDisconnect, moveOpenDoor, moveThroughCorner, moveThroughNPC, moveHeuristicMult, moveTurnCost y moveBetweenTwoCorners afectan el rendimiento. avoidMobiles/openDoors explícito anula los valores correspondientes para esta llamada.
- El resultado 0 no indica la causa exacta. Verifique las coordenadas, la conexión, la resistencia y el registro; No repitas el movimiento infinitamente sin UO.Wait y un límite de intentos.
- El puente principal registra el número de solicitud, las instancias de jugador/Pathfinder/mapa y el índice del mapa. Una nueva solicitud, cambio de contexto o rechazo final da 0; la verificación se repite después de leer las coordenadas y la última devolución de llamada. El tiempo de espera, maxSteps y callback=0 solo detienen la solicitud guardada, no una nueva ruta externa. El Bloqueado Temporal, mientras la recuperación sigue activa, no pierde la posesión: la espera continúa. Para el puente heredado externo sin IApiMovementOwnershipBridge, se conserva el mecanismo compatible anterior.
- El Pathfinder general almacena hasta 8 prohibiciones direccionales X/Y/Z temporales durante 2000 ms, solo en caso de movimiento rechazado de la solicitud activa correspondiente. La rotación, la secuencia desconocida, la resincronización y la solicitud antigua/extraña no crean dicha prohibición. Una nueva solicitud externa y la pérdida del contexto del mapa/jugador los borra. La búsqueda de geometría cargada intenta omitir la transición; es no conocer todos los obstáculos del servidor. Sin cambiar el X/Y/Z del reproductor, se permiten hasta 8 recálculos internos con una pausa de al menos 40 ms. No existe un camino completo o este presupuesto se ha agotado: la ruta termina. Luego, la tarea coordinada se completa después de procesar los pasos enviados; mobile-Follow puede intentarlo nuevamente debido a su retraso.
La devolución de llamada del paso en C# se registra explícitamente a través de RegisterStepCallback(nombre, Func<int,int,int,bool>) o Func<int,int,int,int>. Las coordenadas x/y/z se transmiten como int; false/0 detiene la ruta, true/número distinto de cero continúa. El registro es válido en la ejecución actual y se libera con ella.
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.
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.NewMoveXY((UO.GetX() + 3), UO.GetY(), true, 0, false);
UO.Print("NewMoveXY: " + Convert.ToString(result));Parámetros y flujo de ejecución:
- x/y — objetivo mundial; Optimizado=true, Precisión=0 requiere X/Y preciso, Correr=false especifica caminar.
- ok - int 1 o 0, no la cantidad de celdas pasadas. El objetivo debe estar disponible en el mapa actual.
var x = UO.GetX() + 3;
var y = UO.GetY();
var ok = UO.NewMoveXY(x, y, true, 0, false);
if (Truth(ok))
{
UO.Print("Destination reached");
}
else
{
UO.Print("Destination not reached");
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parámetros y flujo de ejecución:
- 1445/1690 - ejemplo de objetivo; Accuracy=1 permite aparcar cerca. Corriendo=true. StepCallback=0 desactiva la devolución de llamada.
- tiempo de espera=5000 ms; maxSteps=100 movimientos observados; maxDistance=30 se verifica desde el origen.
- AccuracyZ=255 no requiere piso; avoidMobiles=true, openDoors=true, stopOnStuck=true incluyen estas condiciones.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var ok = UO.NewMoveXY(1445, 1690, true, 1, true, 0, 5000, 100, 30, 255, true, true, true);
UO.Print("Move result: " + Convert.ToString(ok));
return null;
}Parámetros y flujo de ejecución:
- StepCallback="AfterStep" recibe tres coordenadas. El registro RegisterStepCallback asocia el nombre con el delegado bool. Cuando Stamina <= 10 regresa false y deja de moverse; true continúa la ruta.
- timeout=5000 ms limita la espera. La devolución de llamada se realiza después de que se detecta un cambio y no se garantiza para cada paso de la red; No hagas una larga espera ni una nueva ruta en él.
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 stepRegistration = RegisterStepCallback("AfterStep", AfterStep);
var ok = UO.NewMoveXY(UO.GetX() + 5, UO.GetY(), true, 0, false, "AfterStep", 5000);
UO.Print("Move result: " + Convert.ToString(ok));
return null;
}
bool AfterStep(int x, int y, int z)
{
UO.Print("Position: " + Convert.ToString(x) + "," + Convert.ToString(y) + "," + Convert.ToString(z));
return UO.Stamina() > 10;
}
private IDisposable RegisterStepCallback(string name, Func<int, int, int, bool> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterStepCallback(name, handler);
private IDisposable RegisterStepCallback(string name, Func<int, int, int, int> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterStepCallback(name, handler);
}Parámetros y flujo de ejecución:
- GoToPoint es una función auxiliar solo para este ejemplo. Sus cuatro parámetros x/y/accuracy/running se describen arriba de la declaración de la función; el cuerpo completo de la función está en el mismo bloque copiado.
- Main evalúa el objetivo y llama a GoToPoint. Agrega optimizado=true, devolución de llamada=0, tiempo de espera=8000 y maxSteps=100, llama a NewMoveXY una vez y pasa el int devuelto a Principal.
- NewMoveXY es un comando de cliente integrado. Su búsqueda A*, verificación de permeabilidad y procesamiento de los pasos del servidor se implementan en el cliente y no en procedimientos ocultos adicionales de este script.
- En este ejemplo, la devolución de llamada está deshabilitada. Si otro ejemplo especifica un nombre de devolución de llamada o llama a una función de script adicional, su definición también debe proporcionarse en su totalidad.
- En C# comprobar si (alcanzado!= 0); un resultado numérico de 0 indica falla. Una comparación directa de int con bool no es aceptable. Una cancelación de emergencia interrumpe la ejecución y no es necesario devolver false.
var x = UO.GetX() + 3;
var y = UO.GetY();
var reached = GoToPoint(x, y, 0, true);
if (Truth(Truth(reached) == true))
{
UO.Print("Destination reached");
}
else
{
UO.Print("Destination not reached");
}
dynamic GoToPoint(dynamic x, dynamic y, dynamic accuracy, dynamic running)
{
dynamic optimized = true;
var callback = 0;
var timeout = 8000;
var maxSteps = 100;
var reached = UO.NewMoveXY(x, y, optimized, accuracy, running, callback, timeout, maxSteps);
return reached;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.OpenDoor();Solicita que se abra la puerta para el personaje.
No hay parámetros.
void - sin valor. Llame en una línea separada; la finalización no confirma la acción del servidor.
- OpenDoor llama a GameActions.OpenDoor a través de Invocar. No se acepta puerta serial; las reglas de búsqueda y descubrimiento pertenecen a GameActions/servidor.
- En los ejemplos, UO.Wait especifica solo una pausa del script; el final de la pausa no prueba que el servidor haya completado la solicitud.
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.
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.OpenDoor");
UO.OpenDoor();Parámetros y flujo de ejecución:
- Solicita que se abra la puerta para el personaje.
UO.OpenDoor();Parámetros y flujo de ejecución:
- OpenDoor llama a GameActions.OpenDoor a través de Invocar. No se acepta puerta serial; las reglas de búsqueda y descubrimiento pertenecen a GameActions/servidor.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
if (Truth(UO.IsOnline()))
{
UO.OpenDoor();
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parámetros y flujo de ejecución:
- En los ejemplos, UO.Wait especifica solo una pausa del script; el final de la pausa no prueba que el servidor haya completado la solicitud.
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()
{
UO.OpenDoor();
UO.Wait(250);
UO.Print("Door request sent");
return null;
}
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.PMove(object? arg0, object? arg1);
void UO.PMove(object? arg0, object? arg1, object? arg2);Comando de movimiento compatible a X/Y mediante pasos clave separados con un límite de 30 segundos.
-
targetX— Mundo objetivo X. -
x— Mundo objetivo X. -
targetY— Mundo objetivo Y. -
y— Mundo objetivo Y. -
z: el tercer argumento compatible se acepta pero se ignora. Para controlar la altura, utilice MoveXYZ.
void: sin valor de retorno. Llame en una línea separada; no es true/false ni el número de pasos.
- Se trata de un movimiento simple hacia el objetivo con una pausa 75 ms entre intentos, sin una búsqueda completa de un desvío. Para nuevos escenarios con obstáculos, use NewMoveXY.
- Si no se alcanza el X/Y exacto en 30 segundos, se muestra un mensaje. No se puede obtener éxito con el resultado void; comparar coordenadas.
- MoveOff deshabilita los pasos clave de este comando, MoveOn lo habilita nuevamente. PMove con el movimiento desactivado todavía puede esperar hasta el límite.
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.
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.PMove");
UO.PMove((UO.GetX() + 1), UO.GetY());Parámetros y flujo de ejecución:
- x/y especifica el destino. MoveOn habilita pasos clave.
- PMove no devuelve un número: la posición se lee por separado.
var x = UO.GetX() + 1;
var y = UO.GetY();
UO.MoveOn();
UO.PMove(x, y);
UO.Print("X=" + Convert.ToString(UO.GetX()));Parámetros y flujo de ejecución:
- Reemplace 1445/1690 con su punto accesible.
- La verificación compara ambas coordenadas; La unidad no es adecuada para si UO.PMove(...).
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var x = 1445;
var y = 1690;
UO.PMove(x, y);
if (Truth(UO.GetX() == x) && Truth(UO.GetY() == y))
{
UO.Print("Exact XY reached");
}
return null;
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parámetros y flujo de ejecución:
- X/Y coincide con los actuales, por lo que no es necesario ir.
- z=20 se ignora y no sube al último piso. Para ello necesitas MoveXYZ con un punto de escalera real.
Intervalo mínimo de paso: caminar - caminar 400 ms, correr 200 ms; montar a caballo - caminar 200 ms, correr 100 ms.
Estos son límites de cliente estándar, no configuraciones definidas automáticamente para su fragmento. La velocidad del servidor y los modos de vuelo se cuentan por separado. Los temporizadores de guiones pueden ralentizar el movimiento, pero no reducen estos límites.
Los pasos, las rutas, Follow, los controles del mouse/teclas y el mapa utilizan la cola compartida del personaje. Reemplazar la ruta, girar o ajustar la posición por parte del servidor no cancela la pausa restante después de la solicitud del paso. Después del retraso, no hay una ráfaga rápida para compensar los fotogramas perdidos. La espera de confirmación, los obstáculos y la mala comunicación pueden ralentizar el movimiento.
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()
{
UO.PMove(UO.GetX(), UO.GetY(), 20);
UO.Print("Actual Z=" + Convert.ToString(UO.GetZ()));
return null;
}
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.PredictedDirection();Lee el lado de la dirección prevista después de los pasos ya en cola del personaje.
No hay parámetros.
dirección int 0..7, sin bit de ejecución. 0 - norte o ausencia de carácter.
- Sólo la función que se muestra en la sintaxis es UO sin argumentos. No hay parámetros de objetivo, serial, type, objetivo, distancia o tiempo de espera. El número que no sea bool, ID o la notación en mosaico: 1 no significa lograr el objetivo.
- GetEndPosition lee la dirección X/Y/Z/del último Mobile.Step ya agregado. Cuando la cola está vacía, lee la posición/dirección actual del personaje. Esta es una lectura O(1): el paso no se recupera, el movimiento y el paquete no se envían, la ruta no se calcula, el comando no espera un logro.
- Direcciones mundiales: 0 norte, 1 noreste, 2 este, 3 sureste, 4 sur, 5 suroeste, 6 oeste, 7 noroeste. La pantalla es isométrica. Direction.Mask elimina la bandera de ejecución; la velocidad no regresa.
- Este es un pronóstico local, no una llegada confirmada. Los pasos nuevos/completados, la falla del servidor, la limpieza de la cola o el teletransporte pueden cambiarlo. Las llamadas a componentes individuales no son atómicas; una coincidencia X no prueba una coincidencia Y/Z ni una confirmación del servidor.
- Invoke realiza una lectura en el hilo del juego; El hilo de trabajo está esperando que el administrador procese la solicitud. La cancelación del guión interrumpe la espera. No se agregan pausas ni solicitudes de red adicionales.
- Las implementaciones externas de IApiBridge sin IPredictedMovementBridge conservan una lectura alternativa de las coordenadas/dirección actuales. Classic UO implementa una interfaz compatible con colas.
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.
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.PredictedDirection();
UO.Print("PredictedDirection: " + Convert.ToString(result));Parámetros y flujo de ejecución:
- predicho guarda una llamada sin argumentos; Convertir.ToString formatea el número del registro.
var predicted = UO.PredictedDirection();
UO.Print("Predicted: " + Convert.ToString(predicted));Parámetros y flujo de ejecución:
- UO.Wait(100) pausa el ejemplo durante 100 ms. el antes y el después pueden coincidir incluso con un movimiento intermedio; estas lecturas no inician un movimiento.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var before = UO.PredictedDirection();
await Delay(100);
var after = UO.PredictedDirection();
if (Truth(before != after))
{
UO.Print("Prediction changed: " + Convert.ToString(before) + " -> " + Convert.ToString(after));
}
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parámetros y flujo de ejecución:
- esperado: un ejemplo de coordenadas/altura/dirección, no un argumento para el comando nativo. PredictionEquals verifica UO.Self(), lee el valor una vez y devuelve 1 (condición cumplida) si es igual; en caso contrario, 0 (condición no cumplida). El código de función completo se muestra debajo de Principal. La coincidencia de un componente no significa llegada.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
if (Truth(Truth(PredictionEquals(4)) == true))
{
UO.Print("Queued endpoint matches this component");
}
else
{
UO.Print("Different component or no player");
}
return null;
}
dynamic PredictionEquals(dynamic expected)
{
if (Truth(UO.Self() == 0))
{
return false;
}
var predicted = UO.PredictedDirection();
return Truth(predicted == expected);
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.PredictedX();Lee la coordenada X prevista después de los pasos ya en cola del personaje.
No hay parámetros.
int X en las celdas del mapa. 0 - coordenada válida o ausencia de carácter.
- Sólo la función que se muestra en la sintaxis es UO sin argumentos. No hay parámetros de objetivo, serial, type, objetivo, distancia o tiempo de espera. El número que no sea bool, ID o la notación en mosaico: 1 no significa lograr el objetivo.
- GetEndPosition lee la dirección X/Y/Z/del último Mobile.Step ya agregado. Cuando la cola está vacía, lee la posición/dirección actual del personaje. Esta es una lectura O(1): el paso no se recupera, el movimiento y el paquete no se envían, la ruta no se calcula, el comando no espera un logro.
- X e Y son coordenadas mundiales/mapa, no píxeles de contenedor. Z es la altura, no el número del piso. Se devuelve un único componente, no una matriz ni el destino final de toda la ruta.
- Este es un pronóstico local, no una llegada confirmada. Los pasos nuevos/completados, la falla del servidor, la limpieza de la cola o el teletransporte pueden cambiarlo. Las llamadas a componentes individuales no son atómicas; una coincidencia X no prueba una coincidencia Y/Z ni una confirmación del servidor.
- Invoke realiza una lectura en el hilo del juego; El hilo de trabajo está esperando que el administrador procese la solicitud. La cancelación del guión interrumpe la espera. No se agregan pausas ni solicitudes de red adicionales.
- Las implementaciones externas de IApiBridge sin IPredictedMovementBridge conservan una lectura alternativa de las coordenadas/dirección actuales. Classic UO implementa una interfaz compatible con colas.
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.
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.PredictedX();
UO.Print("PredictedX: " + Convert.ToString(result));Parámetros y flujo de ejecución:
- predicho guarda una llamada sin argumentos; Convertir.ToString formatea el número del registro.
var predicted = UO.PredictedX();
UO.Print("Predicted: " + Convert.ToString(predicted));Parámetros y flujo de ejecución:
- UO.Wait(100) pausa el ejemplo durante 100 ms. el antes y el después pueden coincidir incluso con un movimiento intermedio; estas lecturas no inician un movimiento.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var before = UO.PredictedX();
await Delay(100);
var after = UO.PredictedX();
if (Truth(before != after))
{
UO.Print("Prediction changed: " + Convert.ToString(before) + " -> " + Convert.ToString(after));
}
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parámetros y flujo de ejecución:
- esperado: un ejemplo de coordenadas/altura/dirección, no un argumento para el comando nativo. PredictionEquals verifica UO.Self(), lee el valor una vez y devuelve 1 (condición cumplida) si es igual; en caso contrario, 0 (condición no cumplida). El código de función completo se muestra debajo de Principal. La coincidencia de un componente no significa llegada.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
if (Truth(Truth(PredictionEquals(1445)) == true))
{
UO.Print("Queued endpoint matches this component");
}
else
{
UO.Print("Different component or no player");
}
return null;
}
dynamic PredictionEquals(dynamic expected)
{
if (Truth(UO.Self() == 0))
{
return false;
}
var predicted = UO.PredictedX();
return Truth(predicted == expected);
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.PredictedY();Lee la coordenada Y prevista después de los pasos ya en cola del personaje.
No hay parámetros.
int Y en las celdas del mapa. 0 - coordenada válida o ausencia de carácter.
- Sólo la función que se muestra en la sintaxis es UO sin argumentos. No hay parámetros de objetivo, serial, type, objetivo, distancia o tiempo de espera. El número que no sea bool, ID o la notación en mosaico: 1 no significa lograr el objetivo.
- GetEndPosition lee la dirección X/Y/Z/del último Mobile.Step ya agregado. Cuando la cola está vacía, lee la posición/dirección actual del personaje. Esta es una lectura O(1): el paso no se recupera, el movimiento y el paquete no se envían, la ruta no se calcula, el comando no espera un logro.
- X e Y son coordenadas mundiales/mapa, no píxeles de contenedor. Z es la altura, no el número del piso. Se devuelve un único componente, no una matriz ni el destino final de toda la ruta.
- Este es un pronóstico local, no una llegada confirmada. Los pasos nuevos/completados, la falla del servidor, la limpieza de la cola o el teletransporte pueden cambiarlo. Las llamadas a componentes individuales no son atómicas; una coincidencia X no prueba una coincidencia Y/Z ni una confirmación del servidor.
- Invoke realiza una lectura en el hilo del juego; El hilo de trabajo está esperando que el administrador procese la solicitud. La cancelación del guión interrumpe la espera. No se agregan pausas ni solicitudes de red adicionales.
- Las implementaciones externas de IApiBridge sin IPredictedMovementBridge conservan una lectura alternativa de las coordenadas/dirección actuales. Classic UO implementa una interfaz compatible con colas.
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.
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.PredictedY();
UO.Print("PredictedY: " + Convert.ToString(result));Parámetros y flujo de ejecución:
- predicho guarda una llamada sin argumentos; Convertir.ToString formatea el número del registro.
var predicted = UO.PredictedY();
UO.Print("Predicted: " + Convert.ToString(predicted));Parámetros y flujo de ejecución:
- UO.Wait(100) pausa el ejemplo durante 100 ms. el antes y el después pueden coincidir incluso con un movimiento intermedio; estas lecturas no inician un movimiento.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var before = UO.PredictedY();
await Delay(100);
var after = UO.PredictedY();
if (Truth(before != after))
{
UO.Print("Prediction changed: " + Convert.ToString(before) + " -> " + Convert.ToString(after));
}
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parámetros y flujo de ejecución:
- esperado: un ejemplo de coordenadas/altura/dirección, no un argumento para el comando nativo. PredictionEquals verifica UO.Self(), lee el valor una vez y devuelve 1 (condición cumplida) si es igual; en caso contrario, 0 (condición no cumplida). El código de función completo se muestra debajo de Principal. La coincidencia de un componente no significa llegada.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
if (Truth(Truth(PredictionEquals(1690)) == true))
{
UO.Print("Queued endpoint matches this component");
}
else
{
UO.Print("Different component or no player");
}
return null;
}
dynamic PredictionEquals(dynamic expected)
{
if (Truth(UO.Self() == 0))
{
return false;
}
var predicted = UO.PredictedY();
return Truth(predicted == expected);
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.PredictedZ();Lee la altura Z prevista después de los pasos ya en cola del personaje.
No hay parámetros.
int Z, altura con signo -128..127; se mantiene un valor negativo. 0 - altura aceptable o ausencia del personaje.
- Sólo la función que se muestra en la sintaxis es UO sin argumentos. No hay parámetros de objetivo, serial, type, objetivo, distancia o tiempo de espera. El número que no sea bool, ID o la notación en mosaico: 1 no significa lograr el objetivo.
- GetEndPosition lee la dirección X/Y/Z/del último Mobile.Step ya agregado. Cuando la cola está vacía, lee la posición/dirección actual del personaje. Esta es una lectura O(1): el paso no se recupera, el movimiento y el paquete no se envían, la ruta no se calcula, el comando no espera un logro.
- X e Y son coordenadas mundiales/mapa, no píxeles de contenedor. Z es la altura, no el número del piso. Se devuelve un único componente, no una matriz ni el destino final de toda la ruta.
- Este es un pronóstico local, no una llegada confirmada. Los pasos nuevos/completados, la falla del servidor, la limpieza de la cola o el teletransporte pueden cambiarlo. Las llamadas a componentes individuales no son atómicas; una coincidencia X no prueba una coincidencia Y/Z ni una confirmación del servidor.
- Invoke realiza una lectura en el hilo del juego; El hilo de trabajo está esperando que el administrador procese la solicitud. La cancelación del guión interrumpe la espera. No se agregan pausas ni solicitudes de red adicionales.
- Las implementaciones externas de IApiBridge sin IPredictedMovementBridge conservan una lectura alternativa de las coordenadas/dirección actuales. Classic UO implementa una interfaz compatible con colas.
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.
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.PredictedZ();
UO.Print("PredictedZ: " + Convert.ToString(result));Parámetros y flujo de ejecución:
- predicho guarda una llamada sin argumentos; Convertir.ToString formatea el número del registro.
var predicted = UO.PredictedZ();
UO.Print("Predicted: " + Convert.ToString(predicted));Parámetros y flujo de ejecución:
- UO.Wait(100) pausa el ejemplo durante 100 ms. el antes y el después pueden coincidir incluso con un movimiento intermedio; estas lecturas no inician un movimiento.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
var before = UO.PredictedZ();
await Delay(100);
var after = UO.PredictedZ();
if (Truth(before != after))
{
UO.Print("Prediction changed: " + Convert.ToString(before) + " -> " + Convert.ToString(after));
}
return null;
}
Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;Parámetros y flujo de ejecución:
- esperado: un ejemplo de coordenadas/altura/dirección, no un argumento para el comando nativo. PredictionEquals verifica UO.Self(), lee el valor una vez y devuelve 1 (condición cumplida) si es igual; en caso contrario, 0 (condición no cumplida). El código de función completo se muestra debajo de Principal. La coincidencia de un componente no significa llegada.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
async public Task<object?> RunScenarioAsync()
{
if (Truth(Truth(PredictionEquals(-4)) == true))
{
UO.Print("Queued endpoint matches this component");
}
else
{
UO.Print("Different component or no player");
}
return null;
}
dynamic PredictionEquals(dynamic expected)
{
if (Truth(UO.Self() == 0))
{
return false;
}
var predicted = UO.PredictedZ();
return Truth(predicted == expected);
}
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
}ClassicUO — Bad Newbie & C# Scripts IDE