Repository navigation
FR UO Topic movement
Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
Accueil · C# · IDE · UO API · A–Z · Exemples · Langues
Mouvement des personnages, construction de chemins, portes, obstacles et retards de pas. Les commandes pour déplacer des objets se trouvent dans Articles → Moving Articles.
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
Chaque carte de commande possède plusieurs scénarios indépendants : code direct, fonctions et classes. Vous trouverez ci-dessous une sélection de courts scénarios ; des restrictions et une analyse complète sont à prévoir.
Paramètres, résultat et tous les scénarios
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;Paramètres, résultat et tous les scénarios
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? directions);-
directionsest une chaîne enregistrée dans la liste héritée. La signification et le format de la valeur dépendent du script compatible qui l'utilise.
void. L'entrée ajoutée ne constitue pas une confirmation du mouvement.
- La valeur est ajoutée à la liste
AddDirde l'état d'exécution actuel. L'appel lui-même ne transmet pas de paquet de mouvement, ne déplace pas le personnage et ne dispose pas d'un getter public documenté pour lire cette liste.
Chaque exemple peut être enregistré dans un fichier séparé .csx et exécuté dans IDE. Les fonctions d'objet UO et d'attente fournissent l'hôte de la session de jeu en cours. Remplacez les noms, coordonnées et adresses de la démo serial par les vôtres.
Exécutez ce code dans un fichier .csx séparé. Les arguments sont visibles dans l’appel ; remplacez les noms, serials et adresses d’exemple par les vôtres.
La commande forme une instruction séparée. Le message précédent indique le début de l’appel et ne confirme aucune action du serveur.
UO.Print("Calling UO.AddDir");
UO.AddDir("E");1. Enregistrez la direction en tant qu'entrée compatible avec l'héritage sans déplacer le personnage. - scénario direct
Paramètres et déroulement de l’exécution :
- Enregistrez la direction en tant qu'entrée compatible avec l'héritage sans déplacer le personnage.
UO.AddDir("E");Paramètres et déroulement de l’exécution :
- Transmettez la valeur de la variable à l'ancienne liste AddDir.
return RunScenario();
object? RunScenario()
{
var directionEntry = "north-east";
UO.AddDir(directionEntry);
return null;
}Paramètres et déroulement de l’exécution :
- Chaque appel ajoute une autre entrée de chaîne à l'état d'exécution.
- La procédure auxiliaire n'envoie pas non plus de commande de mouvement.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
AddLegacyDirection("W");
return null;
}
void AddLegacyDirection(dynamic entry)
{
UO.AddDir(entry);
}
}C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Paramètres: directions (Any)
Résultat: void / Unit.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias. -
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::LegacyList:LegacyList(name). -
InjectionScript.Runtime.InjectionValue.ToString:value.ToString().
Code interne de l’implémentation ; ce n’est pas un script autonome.
case "adddir":
case "addfindlist":
case "addgate":
case "addrecall":
case "addstep":
LegacyList(name).Add(string.Join("|", arguments.Select(value => value.ToString())));
break;Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.AddStep(object? directions);-
directionsest la valeur que le runtime convertit en texte et ajoute à la liste de compatibilitéAddStep. La direction elle-même n’est pas interprétable.
void. L'appel ne renvoie pas de valeur et ne confirme pas le déplacement.
- Chaque appel ajoute une représentation sous forme de chaîne de l'argument à la liste
AddStepde l'état d'exécution actuel. Cette entrée héritée n'envoie pas de commande de mouvement et n'a pas de getter public dans l'implémentation actuelle.
Chaque exemple peut être enregistré dans un fichier séparé .csx et exécuté dans IDE. Les fonctions d'objet UO et d'attente fournissent l'hôte de la session de jeu en cours. Remplacez les noms, coordonnées et adresses de la démo serial par les vôtres.
Exécutez ce code dans un fichier .csx séparé. Les arguments sont visibles dans l’appel ; remplacez les noms, serials et adresses d’exemple par les vôtres.
La commande forme une instruction séparée. Le message précédent indique le début de l’appel et ne confirme aucune action du serveur.
UO.Print("Calling UO.AddStep");
UO.AddStep(2);Paramètres et déroulement de l’exécution :
- Écrivez la valeur dans la liste héritée ; le personnage ne bouge pas.
UO.AddStep(2);2. Valeur du texte de transmission : elle est stockée sous forme d'enregistrement plutôt que exécutée sous forme de direction. - fonction de script
Paramètres et déroulement de l’exécution :
- Passer la valeur du texte : elle est stockée sous forme d'enregistrement plutôt que exécutée sous forme de direction.
return RunScenario();
object? RunScenario()
{
var legacyValue = "east";
UO.AddStep(legacyValue);
return null;
}Paramètres et déroulement de l’exécution :
- Chaque appel ajoute une entrée distincte à AddStep du runtime actuel.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
UO.AddStep(1);
UO.AddStep(2);
return null;
}
}C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Paramètres: directions (Any)
Résultat: void / Unit.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias. -
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::LegacyList:LegacyList(name). -
InjectionScript.Runtime.InjectionValue.ToString:value.ToString().
Code interne de l’implémentation ; ce n’est pas un script autonome.
case "adddir":
case "addfindlist":
case "addgate":
case "addrecall":
case "addstep":
LegacyList(name).Add(string.Join("|", arguments.Select(value => value.ToString())));
break;Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.AlwaysRun();
void UO.AlwaysRun(object? enabled);Lit ou modifie le paramètre de fonctionnement constant du profil ClassicUO actuel.
-
enabled-0désactive le fonctionnement constant ; toute valeur non nulle l'active.
Le formulaire sans argument renvoie 1 si le paramètre est activé, 0 sinon. La forme d'argument renvoie null.
- La valeur est lue à partir du profil actuel. Le paramètre change
AlwaysRunet enregistre le profil actuel. Sans profil actif, le getter renvoie0et le setter signale une erreur dans le journal client et ne modifie pas le paramètre.
Chaque exemple peut être enregistré dans un fichier séparé .csx et exécuté dans IDE. Les fonctions d'objet UO et d'attente fournissent l'hôte de la session de jeu en cours. Remplacez les noms, coordonnées et adresses de la démo serial par les vôtres.
Exécutez ce code dans un fichier .csx séparé. Les arguments sont visibles dans l’appel ; remplacez les noms, serials et adresses d’exemple par les vôtres.
Le résultat d’un seul appel est affiché dans le journal. Un nombre n’est pas converti en bool ; un tableau est affiché par son nombre d’éléments.
var result = UO.AlwaysRun();
UO.Print("AlwaysRun: " + Convert.ToString(result));Paramètres et déroulement de l’exécution :
- Lisez le paramètre ; 1 signifie que le fonctionnement constant est activé.
var isAlwaysRunning = UO.AlwaysRun();
UO.Print(Convert.ToString(isAlwaysRunning));2. Activez l'exécution constante et enregistrez les paramètres de profil actuels. - fonction de script
Paramètres et déroulement de l’exécution :
- Activez l'exécution constante et enregistrez les paramètres de profil actuels.
return RunScenario();
object? RunScenario()
{
UO.AlwaysRun(1);
return null;
}Paramètres et déroulement de l’exécution :
- Désactivez l'exécution constante uniquement si elle est actuellement activée.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
if (Truth(UO.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;
}C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Paramètres: Aucun paramètre.
Résultat: int / Integer.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.AlwaysRun. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.AlwaysRun:bridge.AlwaysRun().
Code interne de l’implémentation ; ce n’est pas un script autonome.
public int AlwaysRun() => bridge.AlwaysRun();Paramètres: enabled (Integer)
Résultat: void / Unit.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.AlwaysRun. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.AlwaysRun:bridge.AlwaysRun(enabled).
Code interne de l’implémentation ; ce n’est pas un script autonome.
public void AlwaysRun(int enabled) => bridge.AlwaysRun(enabled);Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.CalcDir(object? xfrom, object? yfrom, object? xto, object? yto);Calcule la direction d'un point du monde à un autre. Le personnage ne bouge pas.
-
xfrom— Coordonnée X du point de départ. -
yfrom— Coordonnée Y du point de départ. -
xto— La coordonnée d'affectation X. -
yto— La coordonnée d'affectation Y.
int — code de direction : 0=nord, 1=nord-est, 2=est, 3=sud-est, 4=sud, 5=sud-ouest, 6=ouest, 7=nord-ouest. Les points correspondants donnent 100. Ce n'est pas bool : 0 signifie nord, pas échec ; 1 signifie nord-est, pas succès. Ne transmettez pas 100 à la commande step comme direction.
- Calculez uniquement les coordonnées : pas de lots, pas d'attente, pas de chargement de carte, pas de vérification d'obstacles, pas de Z, pas de carte du monde. L'équipe ne recherche pas de parcours praticable et ne garantit pas la réalisation de l'objectif. Les points doivent appartenir au même système de coordonnées ; éviter les obstacles peut allonger le chemin.
- Les quatre paramètres sont nécessaires. Envoyez les coordonnées mondiales int dans la plage documentée 0..65535. object ? dans la signature indique un adaptateur universel, pas le ID de l'article. Ces commandes n'ont pas de valeurs par défaut, de coordonnées à l'intérieur du coffre, de cinquième Z et de surcharge avec un seul objet.
- Les coordonnées d'origine sont soustraites des coordonnées de destination, puis les signes des différences sont vérifiés. La diminution de Y est le nord, l'augmentation de X est l'est. Si les deux coordonnées changent, la diagonale est choisie quelle que soit l'ampleur des différences. Si les deux différences sont nulles - 100.
Chaque exemple peut être enregistré dans un fichier séparé .csx et exécuté dans IDE. Les fonctions d'objet UO et d'attente fournissent l'hôte de la session de jeu en cours. Remplacez les noms, coordonnées et adresses de la démo serial par les vôtres.
Exécutez ce code dans un fichier .csx séparé. Les arguments sont visibles dans l’appel ; remplacez les noms, serials et adresses d’exemple par les vôtres.
Le résultat d’un seul appel est affiché dans le journal. Un nombre n’est pas converti en bool ; un tableau est affiché par son nombre d’éléments.
var result = UO.CalcDir(100, 100, 101, 100);
UO.Print("CalcDir: " + Convert.ToString(result));Paramètres et déroulement de l’exécution :
- Origine (100,100), destination (101,100) : X augmente, Y ne change pas. Retours principaux int 2 - est. La commande move n'est pas appelée.
- int — code de direction : 0=nord, 1=nord-est, 2=est, 3=sud-est, 4=sud, 5=sud-ouest, 6=ouest, 7=nord-ouest. Les points correspondants donnent 100. Ce n'est pas bool : 0 signifie nord, pas échec ; 1 signifie nord-est, pas succès. Ne transmettez pas 100 à la commande step comme direction.
- Les coordonnées d'origine sont soustraites des coordonnées de destination, puis les signes des différences sont vérifiés. La diminution de Y est le nord, l'augmentation de X est l'est. Si les deux coordonnées changent, la diagonale est choisie quelle que soit l'ampleur des différences. Si les deux différences sont nulles - 100.
return UO.CalcDir(100,100,101,100);Paramètres et déroulement de l’exécution :
- Les deux points sont égaux (100,100). direction=100 signifie une correspondance, donc Main renvoie string "déjà là". À différents moments, une autre branche fonctionnera. C'est 100 qui est coché, pas true.
- int — code de direction : 0=nord, 1=nord-est, 2=est, 3=sud-est, 4=sud, 5=sud-ouest, 6=ouest, 7=nord-ouest. Les points correspondants donnent 100. Ce n'est pas bool : 0 signifie nord, pas échec ; 1 signifie nord-est, pas succès. Ne transmettez pas 100 à la commande step comme direction.
- Les coordonnées d'origine sont soustraites des coordonnées de destination, puis les signes des différences sont vérifiés. La diminution de Y est le nord, l'augmentation de X est l'est. Si les deux coordonnées changent, la diagonale est choisie quelle que soit l'ampleur des différences. Si les deux différences sont nulles - 100.
return RunScenario();
object? RunScenario()
{
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;Paramètres et déroulement de l’exécution :
- En passant de (20,20) à (19,21), X diminue, Y augmente : UO.CalcDir renvoie 5. RebuildDirection montre toutes les branches de cet algorithme et donne également 5. Principal renvoie "5:5". Les quatre paramètres assistants ont la même signification de coordonnées.
- int — code de direction : 0=nord, 1=nord-est, 2=est, 3=sud-est, 4=sud, 5=sud-ouest, 6=ouest, 7=nord-ouest. Les points correspondants donnent 100. Ce n'est pas bool : 0 signifie nord, pas échec ; 1 signifie nord-est, pas succès. Ne transmettez pas 100 à la commande step comme direction.
- Les coordonnées d'origine sont soustraites des coordonnées de destination, puis les signes des différences sont vérifiés. La diminution de Y est le nord, l'augmentation de X est l'est. Si les deux coordonnées changent, la diagonale est choisie quelle que soit l'ampleur des différences. Si les deux différences sont nulles - 100.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
var actual = UO.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;
}C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Paramètres: xfrom (Any), yfrom (Any), xto (Any), yto (Any)
Résultat: int / Integer.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
InjectionScript.Runtime.InjectionApiUO.CalculateDirection:CalculateDirection(Arg(0), Arg(1), Arg(2), Arg(3)). -
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg:Arg(0).
Code interne de l’implémentation ; ce n’est pas un script autonome.
case "calcdir": return new InjectionValue(CalculateDirection(Arg(0), Arg(1), Arg(2), Arg(3)));Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.CancelMove();Désactive l'autorisation de mouvements supplémentaires par le script via MoveOff.
Il n'y a pas de paramètres.
void - aucune valeur de retour.
- Appelle MoveOff, qui met le runtime/manager dans l'état MoveEnabled=false. Pour réactiver le mouvement, MoveOn est nécessaire. La commande n'annule pas les étapes déjà envoyées.
Chaque exemple peut être enregistré dans un fichier séparé .csx et exécuté dans IDE. Les fonctions d'objet UO et d'attente fournissent l'hôte de la session de jeu en cours. Remplacez les noms, coordonnées et adresses de la démo serial par les vôtres.
Exécutez ce code dans un fichier .csx séparé. Les arguments sont visibles dans l’appel ; remplacez les noms, serials et adresses d’exemple par les vôtres.
La commande forme une instruction séparée. Le message précédent indique le début de l’appel et ne confirme aucune action du serveur.
UO.Print("Calling UO.CancelMove");
UO.CancelMove();Paramètres et déroulement de l’exécution :
- Les commandes de mouvement suivantes respectent la résolution désactivée.
UO.CancelMove();Paramètres et déroulement de l’exécution :
- MoveOn restaure explicitement la résolution.
return RunScenario();
object? RunScenario()
{
UO.CancelMove();
UO.MoveOn();
return null;
}Paramètres et déroulement de l’exécution :
- Une connexion déconnectée est utilisée comme condition pour interdire les étapes ultérieures.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
if (!(Truth(UO.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;
}C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Paramètres: Aucun paramètre.
Résultat: void / Unit.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias. -
InjectionScript.Runtime.InjectionApiUO.MoveOff:MoveOff().
Code interne de l’implémentation ; ce n’est pas un script autonome.
case "cancelmove": MoveOff(); break;Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.Dir();Lit la direction du caractère à partir du modèle client.
Il n'y a pas de paramètres.
int — direction mobile sans bit d'exécution : 0=N, 1=NE, 2=E, 3=SE, 4=S, 5=SW, 6=W, 7=NW. Pour un mobile inconnu, 0 est renvoyé, ce qui signifie également le nord.
- Les données locales déjà reçues sont lues. La requête n'ouvre pas le statut et n'oblige pas le serveur à envoyer une mise à jour. Après un décès, une transition de map ou une suppression d'objet, les valeurs peuvent changer entre deux appels.
- C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Chaque exemple peut être enregistré dans un fichier séparé .csx et exécuté dans IDE. Les fonctions d'objet UO et d'attente fournissent l'hôte de la session de jeu en cours. Remplacez les noms, coordonnées et adresses de la démo serial par les vôtres.
Exécutez ce code dans un fichier .csx séparé. Les arguments sont visibles dans l’appel ; remplacez les noms, serials et adresses d’exemple par les vôtres.
Le résultat d’un seul appel est affiché dans le journal. Un nombre n’est pas converti en bool ; un tableau est affiché par son nombre d’éléments.
var result = UO.Dir();
UO.Print("Dir: " + Convert.ToString(result));Paramètres et déroulement de l’exécution :
- L'appel sans arguments fait référence à self. La direction du personnage est stockée en valeur.
- Convert.ToString convertit le nombre à sortir et ne change pas la signification du résultat.
var value = UO.Dir();
UO.Print("Dir: " + Convert.ToString(value));Paramètres et déroulement de l’exécution :
- La valeur est lue une fois sans aucun argument. La direction du caractère est utilisée dans le calcul ou la condition affichée.
- Les seuils numériques sont des exemples de conditions de script et non de nouvelles limites client. Le champ stocke les unités de serveur et les restrictions décrites ci-dessus.
return RunScenario();
object? RunScenario()
{
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;Paramètres et déroulement de l’exécution :
- Les deux appels sans argument lisent leur valeur actuelle. UO.Wait(1000) donne une pause en millisecondes entre les prises de vue.
- Changement par rapport : direction du personnage. Un exemple ne change rien au monde et n’attend pas indéfiniment. Les événements au cours de cette seconde peuvent être manqué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 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;
}C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Paramètres: Aucun paramètre.
Résultat: int / Integer.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [Dir]. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetDir:bridge.GetDir(bridge.Self). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self:bridge.Self.
L’appel exécute le delegate du gestionnaire enregistré. La méthode d’enregistrement crée ce delegate lors de la construction de l’API.
Code interne de l’implémentation ; ce n’est pas un script autonome.
() => bridge.GetDir(bridge.Self)Création de l’API: Ces fonctions enregistrent l’API. Elles ne sont pas exécutées à nouveau pour chaque appel de commande.
Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.Direction();Lit la direction du caractère à partir du modèle client.
Il n'y a pas de paramètres.
int — direction mobile sans bit d'exécution : 0=N, 1=NE, 2=E, 3=SE, 4=S, 5=SW, 6=W, 7=NW. Pour un mobile inconnu, 0 est renvoyé, ce qui signifie également le nord.
- Les données locales déjà reçues sont lues. La requête n'ouvre pas le statut et n'oblige pas le serveur à envoyer une mise à jour. Après un décès, une transition de map ou une suppression d'objet, les valeurs peuvent changer entre deux appels.
- C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Chaque exemple peut être enregistré dans un fichier séparé .csx et exécuté dans IDE. Les fonctions d'objet UO et d'attente fournissent l'hôte de la session de jeu en cours. Remplacez les noms, coordonnées et adresses de la démo serial par les vôtres.
Exécutez ce code dans un fichier .csx séparé. Les arguments sont visibles dans l’appel ; remplacez les noms, serials et adresses d’exemple par les vôtres.
Le résultat d’un seul appel est affiché dans le journal. Un nombre n’est pas converti en bool ; un tableau est affiché par son nombre d’éléments.
var result = UO.Direction();
UO.Print("Direction: " + Convert.ToString(result));Paramètres et déroulement de l’exécution :
- L'appel sans arguments fait référence à self. La direction du personnage est stockée en valeur.
- Convert.ToString convertit le nombre à sortir et ne change pas la signification du résultat.
var value = UO.Direction();
UO.Print("Direction: " + Convert.ToString(value));Paramètres et déroulement de l’exécution :
- La valeur est lue une fois sans aucun argument. La direction du caractère est utilisée dans le calcul ou la condition affichée.
- Les seuils numériques sont des exemples de conditions de script et non de nouvelles limites client. Le champ stocke les unités de serveur et les restrictions décrites ci-dessus.
return RunScenario();
object? RunScenario()
{
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;Paramètres et déroulement de l’exécution :
- Les deux appels sans argument lisent leur valeur actuelle. UO.Wait(1000) donne une pause en millisecondes entre les prises de vue.
- Changement par rapport : direction du personnage. Un exemple ne change rien au monde et n’attend pas indéfiniment. Les événements au cours de cette seconde peuvent être manqué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 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;
}C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Paramètres: Aucun paramètre.
Résultat: int / Integer.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [Direction]. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetDir:bridge.GetDir(bridge.Self). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self:bridge.Self.
L’appel exécute le delegate du gestionnaire enregistré. La méthode d’enregistrement crée ce delegate lors de la construction de l’API.
Code interne de l’implémentation ; ce n’est pas un script autonome.
() => bridge.GetDir(bridge.Self)Création de l’API: Ces fonctions enregistrent l’API. Elles ne sont pas exécutées à nouveau pour chaque appel de commande.
Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.FixWalk();Imprime un avis indiquant que le correctif client natif existant FixWalk n'est pas requis par ClassicUO.
Il n'y a pas de paramètres.
void - aucune valeur de retour.
- La branche ExecuteLegacyManualAlias appelle uniquement SystemMessage. Il ne corrige pas le mouvement, la parole, les conteneurs ou le protocole réseau.
Chaque exemple peut être enregistré dans un fichier séparé .csx et exécuté dans IDE. Les fonctions d'objet UO et d'attente fournissent l'hôte de la session de jeu en cours. Remplacez les noms, coordonnées et adresses de la démo serial par les vôtres.
Exécutez ce code dans un fichier .csx séparé. Les arguments sont visibles dans l’appel ; remplacez les noms, serials et adresses d’exemple par les vôtres.
La commande forme une instruction séparée. Le message précédent indique le début de l’appel et ne confirme aucune action du serveur.
UO.Print("Calling UO.FixWalk");
UO.FixWalk();Paramètres et déroulement de l’exécution :
- Le message décrit le manque de besoin de l'ancien correctif.
UO.FixWalk();Paramètres et déroulement de l’exécution :
- La procédure de compatibilité ne change pas le monde du jeu.
return RunScenario();
object? RunScenario()
{
CompatibilityNotice();
return null;
}
void CompatibilityNotice()
{
UO.FixWalk();
}Paramètres et déroulement de l’exécution :
- Après le message de diagnostic, l'exécution continue.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
UO.FixWalk();
UO.Print("continued");
return null;
}
}C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Paramètres: Aucun paramètre.
Résultat: void / Unit.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias. -
InjectionScript.Runtime.InjectionApiUO.SystemMessage:SystemMessage($"{name}: obsolete native-client patch; ClassicUO does not require it.").
Code interne de l’implémentation ; ce n’est pas un script autonome.
case "boxhack":
case "fixtalk":
case "fixwalk":
SystemMessage($"{name}: obsolete native-client patch; ClassicUO does not require it.");
break;Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.Follow();
int UO.Follow(object? target);
int UO.Follow(object? target, object? distance);
int UO.Follow(object? target, object? distance, object? running);
int UO.Follow(object? target, object? distance, object? running, object? stopConditions);
int UO.Follow(object? x, object? y, object? z, object? distance, object? running);
int UO.Follow(object? x, object? y, object? z, object? distance, object? running, object? stopConditions);Permet le suivi en arrière-plan du caractère chargé/NPC ou du mouvement vers le point X, Y, Z. Pendant le mouvement, le client vérifie les conditions d'arrêt transmises ; le script continue son exécution immédiatement après l'appel.
-
target— Caractère série/NPC : int, chaîne hexadécimale/décimale, lasttarget ou nom préalablement enregistré via AddObject. Ce ne sont pas des graphic/type ou des coordonnées. Vous ne pouvez pas vous suivre ni suivre un objet. 0 cesse de suivre. Sans arguments, Follow() l'arrête également ; la vue n'apparaît pas. -
distance— Tolérance X/Y dans les cellules : maximum |dx| et |dy|. Pour le caractère int 1..18, par défaut 1 ; La différence Z jusqu'à 16 est acceptable. Pour le point int 0..18, l'argument est requis : 0 nécessite un X/Y exact, 2 permet de s'arrêter dans deux cellules ; Z doit correspondre exactement. Une valeur non valide ne remplace pas le comportement précédent. -
running- Valeur compatible bool : true/1 - course, false/0 - marche ; la valeur par défaut est true. Les limites de vitesse, d'endurance, de paralysie et d'obstacles du serveur demeurent. L'indicateur n'accélère pas les étapes du serveur. -
stopConditions— Tableau facultatif de conditions d'arrêt : quatrième argument pour le caractère, sixième pour les coordonnées. Chaque élément est un tableau d'exactement trois valeurs [champ, comparaison, seuil]. le champ et la comparaison sont des chaînes, le seuil est int/double ; pour les drapeaux true/false (1/0) conviennent. Le déclenchement de TOUTE condition met fin à Follow (OR). Un tableau vide n'ajoute pas de conditions. Le nombre d'éléments n'est pas limité aux éléments fixes 3/5/10, mais est limité par la mémoire ; Les grandes listes sont vérifiées par morceaux. Les champs et unités autorisés sont répertoriés ci-dessous ; un champ inconnu, un opérateur ou une forme de tableau invalide provoque une erreur avant que l'ancien Follow ne soit remplacé. -
x- Uniquement les formulaires avec des arguments 5/6 : coordonnées du monde entier sur la carte actuelle, 0..65535 et à l'intérieur des limites de la carte chargée. Ce ne sont pas des coordonnées de fenêtre/gump ou serial. Il n'y a pas de transfert vers une autre carte. -
y- Uniquement les formulaires avec des arguments 5/6 : coordonnées du monde entier sur la carte actuelle, 0..65535 et à l'intérieur des limites de la carte chargée. Ce ne sont pas des coordonnées de fenêtre/gump ou serial. Il n'y a pas de transfert vers une autre carte. -
z— Uniquement les formulaires avec des arguments 5/6 : hauteur du monde entier -128..127. Cette hauteur est nécessaire à la réalisation, précisez donc le Z de la surface disponible du sol souhaité. Il n'y a pas de valeurs « Z » distinctes ni de sélection automatique de la hauteur.
int 1 (true) — le mode suivant a été accepté par le client, ou une demande d'arrêt a été effectuée ; int 0 (false) - aucun personnage approprié n'est chargé, le joueur est indisponible/mort, la cible est hors de vue, la distance est incorrecte ou le client ne soutient pas l'équipe. Ce n'est pas le résultat de l'arrivée, ni serial, ni le nombre de pas. Dans C# utilisez if (result != 0) ou if (result == 1); le résultat est de type int, pas bool. Des erreurs de type/nom d'objet inconnu peuvent provoquer une erreur de script. Pour les coordonnées, 0 signifie également X/Y/Z invalide ou tolérance. 1 signifie accepter uniquement la tâche en arrière-plan ; l'arrivée et l'occupation future doivent encore être confirmées.
- Exactement un mode Follow par client : personnage ou coordonnées. Un appel réussi remplace à nouveau la cible et les paramètres. Un défi raté n'annule pas l'objectif précédent. Pour suivre un personnage, il doit déjà être dans la liste des Mobiles chargés dans ClientViewRange ; le point de coordonnées peut être plus éloigné que la vue.
- Lorsque vous atteignez une distance proche du personnage, la marche s'arrête, mais le mode reste activé et reprend le mouvement lorsque la cible s'éloigne. Près du point de repère, la tâche se termine si la tolérance X/Y et le Z exact sont respectés. La commande ne signale pas une accessibilité garantie de l'itinéraire lors de son lancement.
- Follow(), Follow(0), MoverStop(), un mouvement manuel de la souris/flèche, une nouvelle route de script ou le suivi d'un client standard arrêtera ce mode. TerminateAll/Terminate("all") l'arrête également. L'annulation d'un script propriétaire toujours en cours d'exécution l'arrête Follow.
- Les deux modes se terminent lorsque la carte ou le personnage change, que le joueur meurt ou que la connexion est déconnectée. Le suivi du personnage s'arrête également lorsque la cible disparaît de la mémoire/de la vue. L'apparition ultérieure d'une cible ne déclenche pas automatiquement le mode : un nouveau Follow est nécessaire.
- La fermeture de IDE n'arrête pas le mode. La fin normale du script en cours d'exécution laisse Follow activé. Une pause de script n'est pas en soi une pause pour ce mode client ; avant de faire une pause, utilisez Follow(0) lorsque le mouvement doit s'arrêter.
- Pathfinder calcule le chemin en morceaux sur le flux de jeu ; une recherche incomplète n'est pas relancée. Pour mobile la mise à jour de l'itinéraire normal est limitée à 500 ms. Après un échec ou la fin d'un itinéraire sans approche, les trois premiers délais de nouvelle tentative sont de 1000 ms, puis de 2000, 4000 et d'un maximum de 5000 ms. Le compteur de rebonds est réinitialisé lorsque le joueur ou la cible X/Y/Z change ; changer la cible peut réduire l'attente jusqu'à 500 ms. Il n'y a pas de limite générale sur le nombre de répétitions pour une cible mobile disponible : le mode peut rester actif sans bouger, alors réglez-le sur écoulé ou arrêtez-le explicitement. La tâche de coordonnées se termine lorsque le chemin échoue complètement.
- Champs distance/temps : distance — distance actuelle jusqu'à la cible en cellules max(abs(dx),abs(dy)) ; hauteur — différence absolue Z en unités mondiales ; écoulé - millisecondes depuis que ce Follow a été accepté. distance > 12 s'arrête lorsque vous vous déplacez plus loin que 12 cellules, écoulé >= 30000 - après 30 secondes. Un Follow répété et réussi relance le compte à rebours.
- L'état de votre personnage : self.hp / self.mana / self.stam - valeurs actuelles ; self.hppercent / self.manapercent / self.stampercent - pourcentages 0..100 du maximum correspondant. Un maximum inconnu (<=0) signifie une valeur inconnue : la condition pour cette caractéristique n'est pas déclenchée, plutôt que de recevoir le 0 fictif.
- Champs logiques pour votre personnage : self.poisoned (empoisonné), self.paralyzed (paralysé), self.hidden (caché). Valeurs 1/0. Dans le tableau de conditions Follow, la règle pour le champ "self.paralysé" avec l'opérateur "=" et la valeur true cesse de suivre en cas de paralysie. Il s'agit du nom de chaîne du champ de règle, pas de la variable C# self.
- Champs cibles : target.dead - mobile mort, target.hidden - caché, target.visible - visible pour le client (pas CheckLOS), target.hp / target.hppercent - chargé HP/percent. Si HP max est inconnu, la condition HP échoue. Le serveur peut envoyer l'échelle relative HP du personnage de quelqu'un d'autre, donc hppercent est plus pratique pour cela.
- Champs cibles supplémentaires : target.notoriety - statut 0..7 (0 inconnu, 1 Innocent, 2 Allié, 3 Gris, 4 Criminel, 5 Ennemi, 6 Meurtrier, 7 Invulnérable) ; target.body — numérique graphic du corps. Ce ne sont pas des vêtements type. Par exemple target.notoriety != 2 arrête le suivi lorsque le statut d'allié est perdu.
- Une copie des conditions est capturée lors de l'appel, y compris les seuils numériques. La modification du tableau/variable source ne met pas à jour le mode ; répétez Follow avec le nouveau tableau. Le mode annulé ne reprend pas lui-même lorsque la condition n'est plus remplie.
- Les conditions sont vérifiées à la fois pendant le mouvement et lorsque le personnage se trouve déjà près de la cible. Une liste régulière comprenant jusqu'à 64 éléments est vérifiée dans une image de jeu, la vérification suivante n'a pas lieu avant 250 ms. Une liste plus grande - 64 éléments par image, puis une pause 250 ms. Le champ écoulé peut s'arrêter après le seuil pendant la durée du contrôle/trame : ce n'est pas un temporisateur précis.
- Tant que la première vérification de la liste entière n'est pas terminée, un nouvel itinéraire ne commence pas. Si la condition est déjà remplie, Follow renverra 1 pour la demande acceptée, puis s'arrêtera à la mise à jour sans la première étape. Des paquets de pas du mouvement précédent peuvent avoir déjà été envoyés.
- Les nouvelles conditions ne désactivent pas les raisons d'arrêt obligatoires : perte de cible/joueur/carte/lien, décès du joueur, annulation du propriétaire, Terminate tout et mouvement manuel/autre. Le code du script n'est pas exécuté sur le fil de jeu ; Seules les valeurs locales répertoriées sont vérifiées.
- Formes de coordonnées : Follow(x,y,z,distance,course) et Follow(x,y,z,distance,course,stopConditions). Les cinq premiers arguments sont requis. Follow(x,y,z) n'est pas une notation abrégée pour les coordonnées : les trois arguments signifient toujours cible, distance, course.
- En mode coordonnées, la distance dans la condition signifie la distance restante le long de X/Y jusqu'au point, la hauteur est la différence absolue par rapport à son Z ; écoulé et tous les self.* fonctionnent comme d'habitude. Les champs target.* ne sont pas valides : le point n'a pas de HP, de corps ou de statut. Essayer de les transmettre provoque une erreur de script jusqu'à ce que l'ancien mode soit remplacé.
- Les conditions sont vérifiées avant le premier itinéraire, lors de son calcul et pendant le déplacement du personnage. Le déclenchement de n'importe quelle condition supprime la tâche et annule le chemin qui lui appartient. La fréquence et le traitement des grandes listes sont les mêmes que pour suivre un caractère ; les étapes déjà envoyées au serveur peuvent se terminer.
- La tâche de coordonnées se termine lorsque le point est atteint ou lorsque la recherche et le mouvement échouent/se terminent sans l'atteindre. Les tentatives infinies vers un point inaccessible ne sont pas déclenchées. Les recalculs internes normaux de Pathfinder pour les obstacles sont conservés. Une fois terminé, quitter l'emplacement ne reprend pas la tâche.
- Si Pathfinder a déjà envoyé les dernières étapes et terminé le chemin, mais que ces étapes sont toujours en cours d'exécution/en attente de confirmation, la tâche continue de vérifier les conditions. La file d'attente des étapes envoyées elle-même n'est pas effacée : elle doit être traitée par le mécanisme normal de déplacement et de confirmation du serveur.
- La liste peut être assemblée via List.Add à DO ... fin de boucle ou FOR puis transmise une fois à checks.ToArray() comme dernier argument du formulaire approprié. Il n'est pas nécessaire d'appeler à nouveau Follow à chaque itération : cela remplace le mode et réinitialise les temps écoulés. Le nombre de lignes n'est pas limité à un petit nombre, mais l'ensemble des champs pris en charge est limité aux champs répertoriés ci-dessus.
- Après 2000 ms sans changer les X/Y/Z du joueur, mobile-Follow peut redemander le chemin vers la cible stationnaire. La vérification est effectuée uniquement lorsque la prochaine échéance arrive, en dehors de la recherche, après la libération de Player.Steps et de la file d'attente Walker, et lorsque l'étape suivante est autorisée. Il n’y a aucun coût à avancer lentement et à attendre les confirmations ; Les étapes envoyées ne sont pas effacées. Coordonner Follow ne déclenche pas une telle répétition externe sans fin : la restauration de son chemin est gérée par le Pathfinder limité.
- Le Pathfinder général stocke jusqu'à 8 interdictions directionnelles temporaires X/Y/Z pendant 2000 ms, uniquement en cas de mouvement rejeté de la requête active correspondante. La rotation, la séquence inconnue, la resynchronisation et la demande ancienne/étrangère ne créent pas une telle interdiction. Une nouvelle requête externe et la perte du contexte de la carte/du lecteur les effacent. La recherche de géométrie chargée tente de contourner la transition ; il ne s'agit pas de connaître tous les obstacles du serveur. Sans changer les X/Y/Z du lecteur, jusqu'à 8 recalculs internes sont autorisés avec une pause d'au moins 40 ms. Il n'y a pas de parcours complet ou ce budget est épuisé - le parcours se termine. La tâche de coordination se termine ensuite après avoir traité les étapes soumises ; mobile-Follow peut réessayer en raison de son retard.
- Le contrôleur compare le numéro de sa propre demande de mouvement, et non le fait AutoWalking : la fin naturelle du chemin n'est pas considérée comme une commande étrangère. StopOwnedPath transfère le numéro stocké vers StopAutoWalkIfRequestGeneration. La nouvelle requête externe met fin à l'ancien Follow ; l'arrêter n'annule pas le nouvel itinéraire de quelqu'un d'autre.
Chaque exemple peut être enregistré dans un fichier séparé .csx et exécuté dans IDE. Les fonctions d'objet UO et d'attente fournissent l'hôte de la session de jeu en cours. Remplacez les noms, coordonnées et adresses de la démo serial par les vôtres.
Exécutez ce code dans un fichier .csx séparé. Les arguments sont visibles dans l’appel ; remplacez les noms, serials et adresses d’exemple par les vôtres.
Le résultat d’un seul appel est affiché dans le journal. Un nombre n’est pas converti en bool ; un tableau est affiché par son nombre d’éléments.
var result = UO.Follow();
UO.Print("Follow: " + Convert.ToString(result));Paramètres et déroulement de l’exécution :
- leader — serial de la dernière cible. L'unité confirme l'acceptation du régime, pas l'arrivée. Après la fin de la méthode, le mode continue de fonctionner jusqu'à ce que la cible s'arrête/perde.
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;Paramètres et déroulement de l’exécution :
- UO.Wait est mesuré en millisecondes. Follow(0) désactive le mode de suivi général ; les mouvements ultérieurs de la cible ne provoquent plus de mouvement.
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;Paramètres et déroulement de l’exécution :
- distance=2, course=true ; attentes maximales de 20 sur 500 ms. Exists vérifie la présence d'un objet, mais pas l'accessibilité du chemin.
finallyarrête le mode pendant une sortie/erreur normale ; L'annulation d'urgence du propriétaire est également gérée par le client.
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;
}Paramètres et déroulement de l’exécution :
- Arrêt pour TOUTE condition : la cible est plus loin que les cellules 12 OU notre HP pas plus de 40% OU 30 secondes se sont écoulées. Ce n'est pas AND. StopWhen est donné dans son intégralité, il peut être inclus dans Include. L’un signifie l’acceptation, pas l’arrivée.
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;Paramètres et déroulement de l’exécution :
- On s'arrête si la cible a disparu/est morte/n'est plus Allié, qu'il ne reste plus que 5 d'endurance, ou que la différence en Z a dépassé 16. false signifie marcher. ToArray transmet une liste de lignes de condition ; la taille n'est pas précisée à l'avance. Si la cible n'est plus Allié, le mouvement ne commencera pas.
return RunScenario();
object? RunScenario()
{
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;
}Paramètres et déroulement de l’exécution :
- Distance maintenue 1, condition d'arrêt <=3 ; vérifier toutes les 250 ms peut remarquer une réalisation retardée. Le délai d'attente ms 15000 ne permet pas un suivi indéfiniment. Renvoyer Follow signifie toujours acceptation, sans atteindre trois cases.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
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;
}
}Paramètres et déroulement de l’exécution :
- while collecte une condition distincte pour chaque élément de statuts. Arrêtez-vous au statut 5 OU 6, possédez HP <=40% OU après 30000 ms. Les statuts vides ignoreront la boucle, mais les deux conditions suivantes resteront. Ajoutez de nouvelles lignes jusqu'à Follow ; une modification ultérieure de la liste ne modifie pas la copie déjà installée. Pour la vérification des antécédents, le corps de la boucle n’a pas besoin d’être répété.
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. Expressions propres à la fin de la boucle UNTIL et un arrêt obligatoire à Enfin - fonction script
Paramètres et déroulement de l’exécution :
- StopEscort(leader, startedAt) renvoie bool-compatible 1/0 : cible au-delà de 12 cellules OU propre HP <=30 OU 30 secondes se sont écoulées. Ajouter || (une autre_condition); Pour une combinaison obligatoire de deux contrôles, utilisez (conditionA && conditionB). Inconnu HP peut être lu comme 0 ; l'exemple refuse alors de démarrer. Pendant que le script est en cours d'exécution, il vérifie les expressions environ toutes les 250 ms ; la pause du script met ces vérifications en pause. Enfin, distribue un arrêt en sortie/erreur normale ; L'annulation du propriétaire est également suivie par le client. Si la cible a disparu et que le client a déjà arrêté Follow, cette boucle se terminera selon ses propres conditions, au plus tard au contrôle du timeout. Pour travailler après la fin de la méthode, utilisez le quatrième argument, comme dans les exemples précédents.
return RunScenario();
object? RunScenario()
{
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;Paramètres et déroulement de l’exécution :
- Cinq arguments : X=1445, Y=1690, Z=0, tolérance X/Y=0, run. Le retour 1 signifie acceptation et non arrivée déjà effectuée. Une fois sur place, la tâche s'éteindra complètement. Pour arrêter manuellement plus tôt, appelez UO.Follow(0).
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
var 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;
}Paramètres et déroulement de l’exécution :
- À HP <=40%, paralysie, ou après 30 secondes, le client arrête son chemin actuel. Sinon, la tâche se terminera dans deux cellules X/Y de (1445,1690), strictement à Z=0. Les contrôles se poursuivent à la fois pendant la recherche de chemin et pendant le déplacement ; Il ne s'agit pas d'un contrôle unique avant le départ. target.* ne s’applique pas ici.
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;
}Paramètres et déroulement de l’exécution :
- distance=0 dans l'appel spécifie une arrivée exacte, mais la condition distance<=3 termine la tâche plus tôt, lorsque le prochain contrôle remarque une telle distance. false signifie marcher. La différence Z>16 ou 20000 ms arrête également la tâche. La direction ne garantit pas la praticabilité ; remplacez le décalage par votre point d'itinéraire.
Intervalle minimum de pas : marche - marche 400 ms, course 200 ms ; équitation - marche 200 ms, course 100 ms.
Il s'agit de limites client standard et non de paramètres automatiquement définis pour votre partition. La vitesse du serveur et les modes de vol sont comptés séparément. Les minuteries de script peuvent ralentir le mouvement, mais ne réduisent pas ces limites.
Les étapes, les itinéraires, Follow, les commandes souris/touches et la carte utilisent la file d'attente partagée du personnage. Le remplacement de l'itinéraire, le virage ou l'ajustement de la position par le serveur n'annule pas la pause restante après la demande d'étape. Après le délai, il n'y a pas de rafale rapide pour compenser les images perdues. L’attente de confirmation, les obstacles et une mauvaise communication peuvent ralentir le mouvement.
return RunScenario();
object? RunScenario()
{
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;
}C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Paramètres: Aucun paramètre.
Résultat: int / Integer.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.Register [Follow]. -
InjectionScript.Runtime.InjectionApiUO.GetObject:GetObject(values[0]). -
InjectionScript.Runtime.NumberConversions.ToInt:NumberConversions.ToInt(values[1]).
L’appel exécute le delegate du gestionnaire enregistré. La méthode d’enregistrement crée ce delegate lors de la construction de l’API.
Code interne de l’implémentation ; ce n’est pas un script autonome.
values => new InjectionValue(bridge is IApiFollowBridge follow
? follow.Follow(count == 0 ? 0 : GetObject(values[0]),
count < 2 ? 1 : NumberConversions.ToInt(values[1]),
count < 3 || NumberConversions.ToInt(values[2]) != 0) : 0)Paramètres: target (Any)
Résultat: int / Integer.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.Register [Follow]. -
InjectionScript.Runtime.InjectionApiUO.GetObject:GetObject(values[0]). -
InjectionScript.Runtime.NumberConversions.ToInt:NumberConversions.ToInt(values[1]).
L’appel exécute le delegate du gestionnaire enregistré. La méthode d’enregistrement crée ce delegate lors de la construction de l’API.
Code interne de l’implémentation ; ce n’est pas un script autonome.
values => new InjectionValue(bridge is IApiFollowBridge follow
? follow.Follow(count == 0 ? 0 : GetObject(values[0]),
count < 2 ? 1 : NumberConversions.ToInt(values[1]),
count < 3 || NumberConversions.ToInt(values[2]) != 0) : 0)Paramètres: target (Any), distance (Any)
Résultat: int / Integer.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.Register [Follow]. -
InjectionScript.Runtime.InjectionApiUO.GetObject:GetObject(values[0]). -
InjectionScript.Runtime.NumberConversions.ToInt:NumberConversions.ToInt(values[1]).
L’appel exécute le delegate du gestionnaire enregistré. La méthode d’enregistrement crée ce delegate lors de la construction de l’API.
Code interne de l’implémentation ; ce n’est pas un script autonome.
values => new InjectionValue(bridge is IApiFollowBridge follow
? follow.Follow(count == 0 ? 0 : GetObject(values[0]),
count < 2 ? 1 : NumberConversions.ToInt(values[1]),
count < 3 || NumberConversions.ToInt(values[2]) != 0) : 0)Paramètres: target (Any), distance (Any), running (Any)
Résultat: int / Integer.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.Register [Follow]. -
InjectionScript.Runtime.InjectionApiUO.GetObject:GetObject(values[0]). -
InjectionScript.Runtime.NumberConversions.ToInt:NumberConversions.ToInt(values[1]).
L’appel exécute le delegate du gestionnaire enregistré. La méthode d’enregistrement crée ce delegate lors de la construction de l’API.
Code interne de l’implémentation ; ce n’est pas un script autonome.
values => new InjectionValue(bridge is IApiFollowBridge follow
? follow.Follow(count == 0 ? 0 : GetObject(values[0]),
count < 2 ? 1 : NumberConversions.ToInt(values[1]),
count < 3 || NumberConversions.ToInt(values[2]) != 0) : 0)Paramètres: target (Any), distance (Any), running (Any), stopConditions (Any)
Résultat: int / Integer.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.Register [Follow]. -
InjectionScript.Runtime.FollowStopCondition.Parse:FollowStopCondition.Parse(values[3]). -
InjectionScript.Runtime.InjectionApiUO.GetObject:GetObject(values[0]). -
InjectionScript.Runtime.NumberConversions.ToInt:NumberConversions.ToInt(values[1]). -
InjectionScript.Runtime.InjectionApiUO.ToBoolean:ToBoolean(values[2]).
L’appel exécute le delegate du gestionnaire enregistré. La méthode d’enregistrement crée ce delegate lors de la construction de l’API.
Code interne de l’implémentation ; ce n’est pas un script autonome.
values =>
{
FollowStopCondition[] conditions = FollowStopCondition.Parse(values[3]);
return new InjectionValue(bridge is IApiConditionalFollowBridge follow
? follow.Follow(GetObject(values[0]), NumberConversions.ToInt(values[1]), ToBoolean(values[2]), conditions) : 0);
}Paramètres: x (Any), y (Any), z (Any), distance (Any), running (Any)
Résultat: int / Integer.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.Register [Follow]. -
InjectionScript.Runtime.FollowStopCondition.Parse:FollowStopCondition.Parse(values[5], coordinateGoal: true). -
InjectionScript.Runtime.NumberConversions.ToInt:NumberConversions.ToInt(values[0]). -
InjectionScript.Runtime.InjectionApiUO.ToBoolean:ToBoolean(values[4]).
L’appel exécute le delegate du gestionnaire enregistré. La méthode d’enregistrement crée ce delegate lors de la construction de l’API.
Code interne de l’implémentation ; ce n’est pas un script autonome.
values =>
{
FollowStopCondition[] conditions = count == 6
? FollowStopCondition.Parse(values[5], coordinateGoal: true) : Array.Empty<FollowStopCondition>();
return new InjectionValue(bridge is IApiCoordinateFollowBridge follow
? follow.FollowPoint(NumberConversions.ToInt(values[0]), NumberConversions.ToInt(values[1]),
NumberConversions.ToInt(values[2]), NumberConversions.ToInt(values[3]), ToBoolean(values[4]), conditions) : 0);
}Paramètres: x (Any), y (Any), z (Any), distance (Any), running (Any), stopConditions (Any)
Résultat: int / Integer.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.Register [Follow]. -
InjectionScript.Runtime.FollowStopCondition.Parse:FollowStopCondition.Parse(values[5], coordinateGoal: true). -
InjectionScript.Runtime.NumberConversions.ToInt:NumberConversions.ToInt(values[0]). -
InjectionScript.Runtime.InjectionApiUO.ToBoolean:ToBoolean(values[4]).
L’appel exécute le delegate du gestionnaire enregistré. La méthode d’enregistrement crée ce delegate lors de la construction de l’API.
Code interne de l’implémentation ; ce n’est pas un script autonome.
values =>
{
FollowStopCondition[] conditions = count == 6
? FollowStopCondition.Parse(values[5], coordinateGoal: true) : Array.Empty<FollowStopCondition>();
return new InjectionValue(bridge is IApiCoordinateFollowBridge follow
? follow.FollowPoint(NumberConversions.ToInt(values[0]), NumberConversions.ToInt(values[1]),
NumberConversions.ToInt(values[2]), NumberConversions.ToInt(values[3]), ToBoolean(values[4]), conditions) : 0);
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.GetDir();
int UO.GetDir(object? id);Lit la direction du caractère à partir du modèle client.
-
id— Objet facultatif uniquement dans les formes à paramètre unique spécifiées : serial nombre/chaîne hexadécimale, "self", "lasttarget" ou nom AddObject. Ce n'est pas graphic/type. Sans argument, son propre caractère est lu. Avant de lire un autre objet, vérifiez UO.Exists ; un nom inconnu n'ouvre pas la portée.
int — direction mobile sans bit d'exécution : 0=N, 1=NE, 2=E, 3=SE, 4=S, 5=SW, 6=W, 7=NW. Pour un mobile inconnu, 0 est renvoyé, ce qui signifie également le nord.
- Les données locales déjà reçues sont lues. La requête n'ouvre pas le statut et n'oblige pas le serveur à envoyer une mise à jour. Après un décès, une transition de map ou une suppression d'objet, les valeurs peuvent changer entre deux appels.
- C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Chaque exemple peut être enregistré dans un fichier séparé .csx et exécuté dans IDE. Les fonctions d'objet UO et d'attente fournissent l'hôte de la session de jeu en cours. Remplacez les noms, coordonnées et adresses de la démo serial par les vôtres.
Exécutez ce code dans un fichier .csx séparé. Les arguments sont visibles dans l’appel ; remplacez les noms, serials et adresses d’exemple par les vôtres.
Le résultat d’un seul appel est affiché dans le journal. Un nombre n’est pas converti en bool ; un tableau est affiché par son nombre d’éléments.
var result = UO.GetDir();
UO.Print("GetDir: " + Convert.ToString(result));Paramètres et déroulement de l’exécution :
- L'appel sans arguments fait référence à self. La direction du personnage est stockée en valeur.
- Convert.ToString convertit le nombre à sortir et ne change pas la signification du résultat.
var value = UO.GetDir();
UO.Print("GetDir: " + Convert.ToString(value));Paramètres et déroulement de l’exécution :
- La valeur est lue une fois sans aucun argument. La direction du caractère est utilisée dans le calcul ou la condition affichée.
- Les seuils numériques sont des exemples de conditions de script et non de nouvelles limites client. Le champ stocke les unités de serveur et les restrictions décrites ci-dessus.
return RunScenario();
object? RunScenario()
{
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;Paramètres et déroulement de l’exécution :
- L'argument unique sélectionne l'objet lasttarget ; son serial doit être connu du client. Graphic/type n'est pas transféré ici.
- Les données d'un autre objet peuvent être inconnues même si Exists est positif. Pour les coordonnées d'un article dans un sac, la position du conteneur est obtenue et non le point mondial.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
if (Truth(UO.Exists("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;
}C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Paramètres: Aucun paramètre.
Résultat: int / Integer.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.GetDir. -
InjectionScript.Runtime.InjectionApiUO.GetDir:GetDir("self").
Code interne de l’implémentation ; ce n’est pas un script autonome.
public int GetDir() => GetDir("self");Paramètres: id (Integer/String)
Résultat: int / Integer.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.GetDir. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetDir:bridge.GetDir(id).
Code interne de l’implémentation ; ce n’est pas un script autonome.
public int GetDir(int id) => bridge.GetDir(id);Paramètres: id (Integer/String)
Résultat: int / Integer.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.GetDir. -
InjectionScript.Runtime.InjectionApiUO.GetDir:GetDir(GetObject(id)). -
InjectionScript.Runtime.InjectionApiUO.GetObject:GetObject(id).
Code interne de l’implémentation ; ce n’est pas un script autonome.
public int GetDir(string id) => GetDir(GetObject(id));Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.GetDirection();
dynamic UO.GetDirection(object? objID);Lit la direction du caractère à partir du modèle client.
-
objID— Objet facultatif uniquement dans les formes à paramètre unique spécifiées : serial nombre/chaîne hexadécimale, "self", "lasttarget" ou nom AddObject. Ce n'est pas graphic/type. Sans argument, son propre caractère est lu. Avant de lire un autre objet, vérifiez UO.Exists ; un nom inconnu n'ouvre pas la portée.
int — direction mobile sans bit d'exécution : 0=N, 1=NE, 2=E, 3=SE, 4=S, 5=SW, 6=W, 7=NW. Pour un mobile inconnu, 0 est renvoyé, ce qui signifie également le nord.
- Les données locales déjà reçues sont lues. La requête n'ouvre pas le statut et n'oblige pas le serveur à envoyer une mise à jour. Après un décès, une transition de map ou une suppression d'objet, les valeurs peuvent changer entre deux appels.
- C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Chaque exemple peut être enregistré dans un fichier séparé .csx et exécuté dans IDE. Les fonctions d'objet UO et d'attente fournissent l'hôte de la session de jeu en cours. Remplacez les noms, coordonnées et adresses de la démo serial par les vôtres.
Exécutez ce code dans un fichier .csx séparé. Les arguments sont visibles dans l’appel ; remplacez les noms, serials et adresses d’exemple par les vôtres.
Le résultat d’un seul appel est affiché dans le journal. Un nombre n’est pas converti en bool ; un tableau est affiché par son nombre d’éléments.
var result = UO.GetDirection();
UO.Print("GetDirection: " + Convert.ToString(result));Paramètres et déroulement de l’exécution :
- L'appel sans arguments fait référence à self. La direction du personnage est stockée en valeur.
- Convert.ToString convertit le nombre à sortir et ne change pas la signification du résultat.
var value = UO.GetDirection();
UO.Print("GetDirection: " + Convert.ToString(value));Paramètres et déroulement de l’exécution :
- La valeur est lue une fois sans aucun argument. La direction du caractère est utilisée dans le calcul ou la condition affichée.
- Les seuils numériques sont des exemples de conditions de script et non de nouvelles limites client. Le champ stocke les unités de serveur et les restrictions décrites ci-dessus.
return RunScenario();
object? RunScenario()
{
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;Paramètres et déroulement de l’exécution :
- L'argument unique sélectionne l'objet lasttarget ; son serial doit être connu du client. Graphic/type n'est pas transféré ici.
- Les données d'un autre objet peuvent être inconnues même si Exists est positif. Pour les coordonnées d'un article dans un sac, la position du conteneur est obtenue et non le point mondial.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
if (Truth(UO.Exists("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;
}C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Paramètres: Aucun paramètre.
Résultat: int / Integer.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [GetDirection]. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetDir:bridge.GetDir(bridge.Self). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self:bridge.Self.
L’appel exécute le delegate du gestionnaire enregistré. La méthode d’enregistrement crée ce delegate lors de la construction de l’API.
Code interne de l’implémentation ; ce n’est pas un script autonome.
() => bridge.GetDir(bridge.Self)Création de l’API: Ces fonctions enregistrent l’API. Elles ne sont pas exécutées à nouveau pour chaque appel de commande.
Paramètres: objID (Any)
Résultat: dynamic / Any.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetDir:bridge.GetDir(Arg(0)). -
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg:Arg(0).
Code interne de l’implémentation ; ce n’est pas un script autonome.
case "getdirection": return new InjectionValue(bridge.GetDir(Arg(0)));Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.GetPathArray(object? xdst, object? ydst, object? optimized, object? accuracy);Renvoie le chemin depuis la position actuelle du personnage vers X/Y sans effectuer de déplacement.
-
xdst— Coordonnée mondiale X de la destination, 0..65535. Ce n'est pas serial ou une position à l'intérieur d'un gump. -
ydst— Coordonnée mondiale Y de la destination, 0..65535. -
optimized- true permet les transitions diagonales ; false laisse quatre directions droites sous cette forme compatible. Ceci est différent de la signification optimisée de MoveXY. -
accuracy— Tolérance pour X et Y dans les cellules : les deux écarts doivent s'y adapter. La valeur est limitée à la plage 0..20 ; 0 nécessite un X/Y précis.
Tableau d'enregistrements [x,y,z], chaque champ est int. [0] du tableau externe est le point de départ ; la dernière entrée se situe dans la tolérance cible spécifiée. Le nombre d'étapes est ArrayLength(path)-1 uniquement pour un tableau non vide. Un tableau vide [] signifie que le chemin valide complet n'est pas obtenu (cible/carte inaccessible, restrictions ou limite de recherche). Si le point de départ convient déjà, un enregistrement est renvoyé et le nombre d'étapes est 0. Le chemin partiel n'est pas renvoyé.
- L'équipe calcule uniquement l'itinéraire ; il ne démarre pas le mouvement et n'ouvre pas les portes. Pour exécuter, utilisez NewMoveXY/MoveXYZ et vérifiez leur propre résultat.
- La recherche évite les obstacles en considérant que les mouvements adjacents ont le même coût ; sur une carte constante, on recherche le chemin comportant le moins de pas. La perméabilité réelle de chaque côte est vérifiée, y compris la hauteur et les limites des diagonales du client.
- Pas plus de 4096 nœuds ouverts et pas plus de 4096 étapes. La limite de travail peut aboutir à un tableau vide même s'il existe un chemin long et complexe ; diviser les longs itinéraires en sections.
- Dans le client, le calcul est divisé en parties allant jusqu'à 32 nœuds avec une vérification budgétaire d'environ 1 ms entre les nœuds. L'annulation est vérifiée entre les portions. La lecture de la carte reste sur le fil du jeu ; ce n'est pas une promesse d'un temps de lecture de disque individuel fixe.
- La carte peut changer après vérification : les personnages bougent, les portes se ferment, le serveur corrige la situation. Le tableau résultant est un plan pour les données locales disponibles, et non une confirmation du serveur.
- SetBadLocation exclut les cellules, SetBadObject exclut les zones autour des objets du monde chargés appropriés. Un instantané de vos listes d'exécution au moment de la demande est utilisé ; les interdictions d'un autre lancement ne sont pas héritées. La cellule de départ n'est pas vérifiée pour son statut : elle est précisée par le code appelant. Vous ne pouvez pas utiliser un Z arbitraire à l’intérieur d’un mur comme position de départ valide.
- La carte actuelle, la source X/Y/Z et la cible Z sont extraites du personnage. Tolérance Z=255. Il n'y a pas de filtres mobiles/statiques supplémentaires ni d'autorisation pour les portes fermées sous forme de quatre arguments.
Chaque exemple peut être enregistré dans un fichier séparé .csx et exécuté dans IDE. Les fonctions d'objet UO et d'attente fournissent l'hôte de la session de jeu en cours. Remplacez les noms, coordonnées et adresses de la démo serial par les vôtres.
Exécutez ce code dans un fichier .csx séparé. Les arguments sont visibles dans l’appel ; remplacez les noms, serials et adresses d’exemple par les vôtres.
Le résultat d’un seul appel est affiché dans le journal. Un nombre n’est pas converti en bool ; un tableau est affiché par son nombre d’éléments.
object? result = UO.GetPathArray(UO.GetX() + 5, UO.GetY(), true, 0);
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Paramètres et déroulement de l’exécution :
- Xdst - cinq cellules à l'est ; Ydst ancien; Optimisé=true ; Précision=0.
- le nombre inclut le point de départ. La soustraction 1 n'est effectuée qu'après avoir vérifié un tableau non vide.
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;Paramètres et déroulement de l’exécution :
- Cible 1445/1690 ; Optimized=false exclut les diagonales ; Accuracy=1 résout la cellule la plus proche dans le carré de tolérance.
- point[0]/[1]/[2] - X/Y/Z. Ce n'est pas un type graphic, serial ou surface.
return RunScenario();
object? RunScenario()
{
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;Paramètres et déroulement de l’exécution :
- La première équipe ne compte que le chemin. Le second vérifie/exécute à nouveau le mouvement, callback=0, timeout=5000.
- Si vous avez juste besoin d'y aller, le GetPathArray préliminaire est facultatif et ajoute du travail.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
var x = UO.GetX() + 3;
var y = UO.GetY();
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;
}C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Paramètres: xdst (Any), ydst (Any), optimized (Any), accuracy (Any)
Résultat: dynamic / Any.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
InjectionScript.Runtime.InjectionApiUO.BuildPortablePath:BuildPortablePath(bridge.GetX(bridge.Self), bridge.GetY(bridge.Self), bridge.GetZ(bridge.Self), Arg(0), Arg(1), bridge.GetZ(bridge.Self), bridge.WorldNumber, Arg(3), 255, Arg(2) != 0, false). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetX:bridge.GetX(bridge.Self). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetY:bridge.GetY(bridge.Self). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetZ:bridge.GetZ(bridge.Self). -
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg:Arg(0). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self:bridge.Self. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.WorldNumber:bridge.WorldNumber.
Code interne de l’implémentation ; ce n’est pas un script autonome.
case "getpatharray":
return BuildPortablePath(bridge.GetX(bridge.Self), bridge.GetY(bridge.Self), bridge.GetZ(bridge.Self),
Arg(0), Arg(1), bridge.GetZ(bridge.Self), bridge.WorldNumber, Arg(3), 255, Arg(2) != 0, false);Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.GetPathArray3D(object? startX, object? startY, object? startZ, object? finishX, object? finishY, object? finishZ, object? map, object? accuracyXY, object? accuracyZ, object? run);
dynamic UO.GetPathArray3D(object? startX, object? startY, object? startZ, object? finishX, object? finishY, object? finishZ, object? map, object? accuracyXY, object? accuracyZ, object? run, object? maxSteps);
dynamic UO.GetPathArray3D(object? startX, object? startY, object? startZ, object? finishX, object? finishY, object? finishZ, object? map, object? accuracyXY, object? accuracyZ, object? run, object? maxSteps, object? maxDistance);
dynamic UO.GetPathArray3D(object? startX, object? startY, object? startZ, object? finishX, object? finishY, object? finishZ, object? map, object? accuracyXY, object? accuracyZ, object? run, object? maxSteps, object? maxDistance, object? avoidMobiles);
dynamic UO.GetPathArray3D(object? startX, object? startY, object? startZ, object? finishX, object? finishY, object? finishZ, object? map, object? accuracyXY, object? accuracyZ, object? run, object? maxSteps, object? maxDistance, object? avoidMobiles, object? avoidStatics);
dynamic UO.GetPathArray3D(object? startX, object? startY, object? startZ, object? finishX, object? finishY, object? finishZ, object? map, object? accuracyXY, object? accuracyZ, object? run, object? maxSteps, object? maxDistance, object? avoidMobiles, object? avoidStatics, object? allowDoors);
dynamic UO.GetPathArray3D(object? startX, object? startY, object? startZ, object? finishX, object? finishY, object? finishZ, object? map, object? accuracyXY, object? accuracyZ, object? run, object? maxSteps, object? maxDistance, object? avoidMobiles, object? avoidStatics, object? allowDoors, object? allowDiagonal);Calcule un tableau du chemin complet entre deux points dans le monde avec contrôle de la hauteur et filtres supplémentaires.
-
startX— Monde initial X, 0..65535. -
startY— Monde initial Y, 0..65535. -
startZ— Hauteur initiale -128..127. -
finishX— Ciblez le monde X, 0..65535. -
finishY— Ciblez le monde Y, 0..65535. -
finishZ— Hauteur cible -128..127. -
map— Numéro de la carte actuellement chargée, par exemple UO.WorldNum(). L'autre carte donne un tableau vide comprenant la correspondance X/Y/Z. -
accuracyXY— Tolérance pour X et Y dans les cellules : les deux écarts doivent s'y adapter. La valeur est limitée à la plage 0..20 ; 0 nécessite un X/Y précis. -
accuracyZ— Tolérance de hauteur : abs (Z réel - Z requis), limité par 0..255. Zéro nécessite une altitude précise ; 255 désactive virtuellement la limite Z. -
run- Indicateur d'exécution compatible requis. La requête ne bouge rien ; sous cette forme, Optimisé est toujours true, donc l'exécution ne modifie pas la séquence de cellules ni le nombre d'étapes. -
maxSteps— Limite facultative du nombre de bords de chemin, sans point de départ. 0/négatif/absent utilise la limite générale 4096. Les cellules sont considérées ici, contrairement aux changements observés dans NewMoveXY. -
maxDistance— Limite facultative de la distance initiale max(abs(dx),abs(dy)) jusqu'à la cible. 0/absence le désactive. Il ne s'agit pas de l'écart autorisé lors du parcours ni de la longueur du chemin trouvé. -
avoidMobiles- true exclut les caractères chargés X/Y, sauf self, par instantané au début de l'appel ; La hauteur de ce filtre n'est pas prise en compte. La valeur par défaut est false. Le contrôle normal de dédouanement du client s’applique toujours. -
avoidStatics- true exclut une cellule avec toute entrée statique, même traversable ou à une hauteur différente. La valeur par défaut est false. Il s’agit d’un filtre strict, et pas seulement d’une interdiction des murs infranchissables. -
allowDoors- true permet un chemin provisoire à travers une tuile de porte trouvée, même si la porte fermée échoue au contrôle normal. La valeur par défaut est false. La porte ne s'ouvre pas ; l'accès, le Z et la perméabilité doivent être à nouveau vérifiés en cours d'exécution. -
allowDiagonal- true/absent autorise huit directions avec vérification d'angle ; false - seulement quatre directions vers l'avant.
Tableau d'enregistrements [x,y,z], chaque champ est int. [0] du tableau externe est le point de départ ; la dernière entrée se situe dans la tolérance cible spécifiée. Le nombre d'étapes est ArrayLength(path)-1 uniquement pour un tableau non vide. Un tableau vide [] signifie que le chemin valide complet n'est pas obtenu (cible/carte inaccessible, restrictions ou limite de recherche). Si le point de départ convient déjà, un enregistrement est renvoyé et le nombre d'étapes est 0. Le chemin partiel n'est pas renvoyé.
- L'équipe calcule uniquement l'itinéraire ; il ne démarre pas le mouvement et n'ouvre pas les portes. Pour exécuter, utilisez NewMoveXY/MoveXYZ et vérifiez leur propre résultat.
- La recherche évite les obstacles en considérant que les mouvements adjacents ont le même coût ; sur une carte constante, on recherche le chemin comportant le moins de pas. La perméabilité réelle de chaque côte est vérifiée, y compris la hauteur et les limites des diagonales du client.
- Pas plus de 4096 nœuds ouverts et pas plus de 4096 étapes. La limite de travail peut aboutir à un tableau vide même s'il existe un chemin long et complexe ; diviser les longs itinéraires en sections.
- Dans le client, le calcul est divisé en parties allant jusqu'à 32 nœuds avec une vérification budgétaire d'environ 1 ms entre les nœuds. L'annulation est vérifiée entre les portions. La lecture de la carte reste sur le fil du jeu ; ce n'est pas une promesse d'un temps de lecture de disque individuel fixe.
- La carte peut changer après vérification : les personnages bougent, les portes se ferment, le serveur corrige la situation. Le tableau résultant est un plan pour les données locales disponibles, et non une confirmation du serveur.
- SetBadLocation exclut les cellules, SetBadObject exclut les zones autour des objets du monde chargés appropriés. Un instantané de vos listes d'exécution au moment de la demande est utilisé ; les interdictions d'un autre lancement ne sont pas héritées. La cellule de départ n'est pas vérifiée pour son statut : elle est précisée par le code appelant. Vous ne pouvez pas utiliser un Z arbitraire à l’intérieur d’un mur comme position de départ valide.
Chaque exemple peut être enregistré dans un fichier séparé .csx et exécuté dans IDE. Les fonctions d'objet UO et d'attente fournissent l'hôte de la session de jeu en cours. Remplacez les noms, coordonnées et adresses de la démo serial par les vôtres.
Exécutez ce code dans un fichier .csx séparé. Les arguments sont visibles dans l’appel ; remplacez les noms, serials et adresses d’exemple par les vôtres.
Le résultat d’un seul appel est affiché dans le journal. Un nombre n’est pas converti en bool ; un tableau est affiché par son nombre d’éléments.
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));Paramètres et déroulement de l’exécution :
- Les trois premières valeurs sont les X/Y/Z d'origine ; les trois suivants sont le but.
- map=WorldNum(), accuracyXY=0, accuracyZ=0 nécessitent une position précise. run=false ne déclenche pas la marche.
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;Paramètres et déroulement de l’exécution :
- Cible 1445/1690/20 ; accuracyXY=1, accuracyZ=2; run=true reste un indicateur de compatibilité.
- maxSteps=80, maxDistance=30; avoidMobiles=true, avoidStatics=false, allowDoors=true, allowDiagonal=false. Le tableau est peut-être vide.
- Le dégagement des portes est une hypothèse de planification ; il n'y a aucune garantie d'ouverture et de passage.
return RunScenario();
object? RunScenario()
{
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;Paramètres et déroulement de l’exécution :
- accuracyXY=2/accuracyZ=5 résolvent le point approprié le plus proche ; maxSteps=100.
- last est la dernière entrée du plan, pas la position actuelle du personnage. L'équipe ne le bouge pas.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
var 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;
}C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
UO.GetPathArray3D(startX, startY, startZ, finishX, finishY, finishZ, map, accuracyXY, accuracyZ, run) — UO.GetPathArray3D(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)
Paramètres: startX (Any), startY (Any), startZ (Any), finishX (Any), finishY (Any), finishZ (Any), map (Any), accuracyXY (Any), accuracyZ (Any), run (Any)
Résultat: dynamic / Array.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.Register [GetPathArray3D]. -
InjectionScript.Runtime.InjectionApiUO.CompactGetPathArray3D:CompactGetPathArray3D(values).
L’appel exécute le delegate du gestionnaire enregistré. La méthode d’enregistrement crée ce delegate lors de la construction de l’API.
Code interne de l’implémentation ; ce n’est pas un script autonome.
values => CompactGetPathArray3D(values)
UO.GetPathArray3D(startX, startY, startZ, finishX, finishY, finishZ, map, accuracyXY, accuracyZ, run, maxSteps) — UO.GetPathArray3D(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)
Paramètres: startX (Any), startY (Any), startZ (Any), finishX (Any), finishY (Any), finishZ (Any), map (Any), accuracyXY (Any), accuracyZ (Any), run (Any), maxSteps (Any)
Résultat: dynamic / Array.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.Register [GetPathArray3D]. -
InjectionScript.Runtime.InjectionApiUO.CompactGetPathArray3D:CompactGetPathArray3D(values).
L’appel exécute le delegate du gestionnaire enregistré. La méthode d’enregistrement crée ce delegate lors de la construction de l’API.
Code interne de l’implémentation ; ce n’est pas un script autonome.
values => CompactGetPathArray3D(values)
UO.GetPathArray3D(startX, startY, startZ, finishX, finishY, finishZ, map, accuracyXY, accuracyZ, run, maxSteps, maxDistance) — UO.GetPathArray3D(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)
Paramètres: startX (Any), startY (Any), startZ (Any), finishX (Any), finishY (Any), finishZ (Any), map (Any), accuracyXY (Any), accuracyZ (Any), run (Any), maxSteps (Any), maxDistance (Any)
Résultat: dynamic / Array.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.Register [GetPathArray3D]. -
InjectionScript.Runtime.InjectionApiUO.CompactGetPathArray3D:CompactGetPathArray3D(values).
L’appel exécute le delegate du gestionnaire enregistré. La méthode d’enregistrement crée ce delegate lors de la construction de l’API.
Code interne de l’implémentation ; ce n’est pas un script autonome.
values => CompactGetPathArray3D(values)
UO.GetPathArray3D(startX, startY, startZ, finishX, finishY, finishZ, map, accuracyXY, accuracyZ, run, maxSteps, maxDistance, avoidMobiles) — UO.GetPathArray3D(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)
Paramètres: startX (Any), startY (Any), startZ (Any), finishX (Any), finishY (Any), finishZ (Any), map (Any), accuracyXY (Any), accuracyZ (Any), run (Any), maxSteps (Any), maxDistance (Any), avoidMobiles (Any)
Résultat: dynamic / Array.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.Register [GetPathArray3D]. -
InjectionScript.Runtime.InjectionApiUO.CompactGetPathArray3D:CompactGetPathArray3D(values).
L’appel exécute le delegate du gestionnaire enregistré. La méthode d’enregistrement crée ce delegate lors de la construction de l’API.
Code interne de l’implémentation ; ce n’est pas un script autonome.
values => CompactGetPathArray3D(values)
UO.GetPathArray3D(startX, startY, startZ, finishX, finishY, finishZ, map, accuracyXY, accuracyZ, run, maxSteps, maxDistance, avoidMobiles, avoidStatics) — UO.GetPathArray3D(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)
Paramètres: startX (Any), startY (Any), startZ (Any), finishX (Any), finishY (Any), finishZ (Any), map (Any), accuracyXY (Any), accuracyZ (Any), run (Any), maxSteps (Any), maxDistance (Any), avoidMobiles (Any), avoidStatics (Any)
Résultat: dynamic / Array.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.Register [GetPathArray3D]. -
InjectionScript.Runtime.InjectionApiUO.CompactGetPathArray3D:CompactGetPathArray3D(values).
L’appel exécute le delegate du gestionnaire enregistré. La méthode d’enregistrement crée ce delegate lors de la construction de l’API.
Code interne de l’implémentation ; ce n’est pas un script autonome.
values => CompactGetPathArray3D(values)
UO.GetPathArray3D(startX, startY, startZ, finishX, finishY, finishZ, map, accuracyXY, accuracyZ, run, maxSteps, maxDistance, avoidMobiles, avoidStatics, allowDoors) — UO.GetPathArray3D(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)
Paramètres: startX (Any), startY (Any), startZ (Any), finishX (Any), finishY (Any), finishZ (Any), map (Any), accuracyXY (Any), accuracyZ (Any), run (Any), maxSteps (Any), maxDistance (Any), avoidMobiles (Any), avoidStatics (Any), allowDoors (Any)
Résultat: dynamic / Array.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.Register [GetPathArray3D]. -
InjectionScript.Runtime.InjectionApiUO.CompactGetPathArray3D:CompactGetPathArray3D(values).
L’appel exécute le delegate du gestionnaire enregistré. La méthode d’enregistrement crée ce delegate lors de la construction de l’API.
Code interne de l’implémentation ; ce n’est pas un script autonome.
values => CompactGetPathArray3D(values)
UO.GetPathArray3D(startX, startY, startZ, finishX, finishY, finishZ, map, accuracyXY, accuracyZ, run, maxSteps, maxDistance, avoidMobiles, avoidStatics, allowDoors, allowDiagonal) — UO.GetPathArray3D(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)
Paramètres: startX (Any), startY (Any), startZ (Any), finishX (Any), finishY (Any), finishZ (Any), map (Any), accuracyXY (Any), accuracyZ (Any), run (Any), maxSteps (Any), maxDistance (Any), avoidMobiles (Any), avoidStatics (Any), allowDoors (Any), allowDiagonal (Any)
Résultat: dynamic / Array.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.Register [GetPathArray3D]. -
InjectionScript.Runtime.InjectionApiUO.CompactGetPathArray3D:CompactGetPathArray3D(values).
L’appel exécute le delegate du gestionnaire enregistré. La méthode d’enregistrement crée ce delegate lors de la construction de l’API.
Code interne de l’implémentation ; ce n’est pas un script autonome.
values => CompactGetPathArray3D(values)Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.GetRun();
int UO.GetRun(object? id);Vérifie le drapeau en marche dans la dernière direction connue du mobile.
-
id— Obligatoire serial/ID d'un objet spécifique : int, chaîne hexadécimale ou alias self, backpack, lasttarget, lastobject, lastcontainer, laststatus, finditem, lastcorpse ou le nom AddObject. Ce n'est pas graphic/type. Le nom non spécifié se résout en 0 ; la commande n'ouvre aucune nouvelle cible. GetRun a également la forme GetRun() pour self.
int 1 - mobile chargé a l'attribut Direction.Running. int 0 - l'attribut est manquant, l'objet n'est pas mobile, inconnu ou supprimé. Le dernier drapeau en marche peut être conservé après l'arrêt. Il ne s'agit pas de l'activité du parcours, ni de la vitesse ou du nombre de pas restants. Pour déplacer self, utilisez également Moving().
Le résultat de la commande est un indicateur numérique : 1 signifie une condition remplie, 0 signifie une condition non remplie. Après var result = command(...) vérifiez si (result != 0) ou if (result == 0). Enregistrez le résultat d'un appel : un appel répété peut effectuer à nouveau l'action ou lire l'état qui a déjà changé.
- Le modèle client local est lu ; Il n'y a aucune requête au serveur, pas d'attente ni de déplacement.
- Le résultat fait référence au moment de la lecture. Après UO.Wait ou une autre action, l'objet et ses drapeaux peuvent changer.
- Le dernier drapeau en marche peut être conservé après l'arrêt. Il ne s'agit pas de l'activité du parcours, ni de la vitesse ou du nombre de pas restants. Pour déplacer self, utilisez également Moving().
Chaque exemple peut être enregistré dans un fichier séparé .csx et exécuté dans IDE. Les fonctions d'objet UO et d'attente fournissent l'hôte de la session de jeu en cours. Remplacez les noms, coordonnées et adresses de la démo serial par les vôtres.
Exécutez ce code dans un fichier .csx séparé. Les arguments sont visibles dans l’appel ; remplacez les noms, serials et adresses d’exemple par les vôtres.
Le résultat d’un seul appel est affiché dans le journal. Un nombre n’est pas converti en bool ; un tableau est affiché par son nombre d’éléments.
var result = UO.GetRun("self");
UO.Print("GetRun: " + Convert.ToString(result));Paramètres et déroulement de l’exécution :
- L'argument self sélectionne explicitement son caractère. état - 1/0 uniquement.
- Le dernier drapeau en marche peut être conservé après l'arrêt. Il ne s'agit pas de l'activité du parcours, ni de la vitesse ou du nombre de pas restants. Pour déplacer self, utilisez également 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));Paramètres et déroulement de l’exécution :
- IsNpc exclut le sujet et l'objet inconnu. target stocke un seul serial plutôt qu'une référence en direct à un lasttarget changeant.
- Le résultat fait référence au champ Direction.Running. Les données ne sont mises à jour qu'une fois que le client a reçu l'état approprié.
return RunScenario();
object? RunScenario()
{
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;Paramètres et déroulement de l’exécution :
- UO.Wait(500) — pause en millisecondes. Après cela, il est vérifié séparément que mobile existe toujours.
- Deux photographies sont comparées. Des modifications intermédiaires peuvent être manquées, et il ne s'agit pas d'un abonnement continu aux événements du serveur.
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;
}C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Paramètres: Aucun paramètre.
Résultat: int / Integer.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.GetRun. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetRun:bridge.GetRun(bridge.Self). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self:bridge.Self.
Code interne de l’implémentation ; ce n’est pas un script autonome.
public int GetRun() => bridge.GetRun(bridge.Self);Paramètres: id (Any)
Résultat: int / Integer.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.GetRun. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetRun:bridge.GetRun(GetObject(id)). -
InjectionScript.Runtime.InjectionApiUO.GetObject:GetObject(id).
Code interne de l’implémentation ; ce n’est pas un script autonome.
public int GetRun(InjectionValue id) => bridge.GetRun(GetObject(id));Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.GetRunMountTimer();Affiche l'intervalle configuré d'un pas de course d'un cheval en millisecondes. Utile pour vérifier le mode, estimer le timing et enregistrer le réglage avant de ralentir temporairement.
Il n'y a pas de paramètres.
int de 100 à 2000 inclus - intervalle configuré en millisecondes. La valeur par défaut est 100. Il s'agit du nombre de fois, pas de true/false, ni de ID, et non du nombre de cellules passées.
- Le réglage s'applique au mode de conduite. La valeur standard et minimale autorisée est 100 ms ; la limite supérieure est 2000 ms. Les trois autres modes ont des paramètres distincts.
- Il s'agit de l'intervalle de mouvement local du personnage, et non du ping, du FPS, du délai d'attente de recherche de chemin ou de la durée mesurée des étapes du serveur. Augmenter le nombre ralentit le mouvement ; diminuer en dessous de l'intervalle standard n'accélère pas l'envoi des paquets.
- L'équipe elle-même ne commence pas à bouger, ne monte pas sur la monture et ne change pas le mode marche/course. Le mode est sélectionné pendant la conduite ; le mode de vitesse et le vol spécifiés par le serveur sont également pris en compte par le client.
- Le paramétrage est général pour le déplacement de ce client : il peut être utilisé par le contrôle manuel, la carte d'itinéraire et d'autres scripts. En le modifiant temporairement, conserver la valeur précédente et la restaurer après l'opération ; ne changez pas un mode en même temps à partir de plusieurs procédures.
- Les pas de virage et de déviation sont différents des mouvements normaux. La confirmation du serveur, les retards de communication et les obstacles peuvent augmenter le temps réel. Le client n'envoie pas une série d'étapes accélérées pour rattraper les images manquantes.
Chaque exemple peut être enregistré dans un fichier séparé .csx et exécuté dans IDE. Les fonctions d'objet UO et d'attente fournissent l'hôte de la session de jeu en cours. Remplacez les noms, coordonnées et adresses de la démo serial par les vôtres.
Exécutez ce code dans un fichier .csx séparé. Les arguments sont visibles dans l’appel ; remplacez les noms, serials et adresses d’exemple par les vôtres.
Le résultat d’un seul appel est affiché dans le journal. Un nombre n’est pas converti en bool ; un tableau est affiché par son nombre d’éléments.
object? result = UO.GetRunMountTimer();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Paramètres et déroulement de l’exécution :
- UO.GetRunMountTimer() est appelé sans arguments. delayMs — intervalle de course à cheval ; les autres modes ne sont pas mesurés ici.
var delayMs = UO.GetRunMountTimer();
UO.Print("Movement delay, ms: " + Convert.ToString(delayMs));Paramètres et déroulement de l’exécution :
- steps=5 est le nombre d'étapes à évaluer, pas un paramètre de commande. La multiplication donne uniquement la contribution des délais configurés ; il ne s'agit pas d'une promesse d'heure d'arrivée ou d'un délai d'attente d'itinéraire.
return RunScenario();
object? RunScenario()
{
var steps = 5;
var delayMs = UO.GetRunMountTimer();
var estimateMs = steps * delayMs;
UO.Print("Step-delay budget, ms: " + Convert.ToString(estimateMs));
return null;
}Paramètres et déroulement de l’exécution :
- précédent est comparé à 100 ms. L'intervalle standard est défini, les trois autres modes sont enregistrés. Le personnage ne bouge pas du défi lui-même.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
var previous = UO.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;
}C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Paramètres: Aucun paramètre.
Résultat: dynamic / Any.
Pendant un appel:
Code interne de l’implémentation ; ce n’est pas un script autonome.
case "getrunmounttimer": return new InjectionValue(state.RunMountTimer);Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.GetRunUnMountTimer();Affiche l'intervalle configuré d'un pas de marche en millisecondes. Utile pour vérifier le mode, estimer le timing et enregistrer le réglage avant de ralentir temporairement.
Il n'y a pas de paramètres.
int de 200 à 2000 inclus - intervalle configuré en millisecondes. La valeur par défaut est 200. Il s'agit du nombre de fois, pas de true/false, ni de ID, et non du nombre de cellules passées.
- Le réglage s'applique au mode marche. La valeur standard et minimale autorisée est 200 ms ; la limite supérieure est 2000 ms. Les trois autres modes ont des paramètres distincts.
- Il s'agit de l'intervalle de mouvement local du personnage, et non du ping, du FPS, du délai d'attente de recherche de chemin ou de la durée mesurée des étapes du serveur. Augmenter le nombre ralentit le mouvement ; diminuer en dessous de l'intervalle standard n'accélère pas l'envoi des paquets.
- L'équipe elle-même ne commence pas à bouger, ne monte pas sur la monture et ne change pas le mode marche/course. Le mode est sélectionné pendant la conduite ; le mode de vitesse et le vol spécifiés par le serveur sont également pris en compte par le client.
- Le paramétrage est général pour le déplacement de ce client : il peut être utilisé par le contrôle manuel, la carte d'itinéraire et d'autres scripts. En le modifiant temporairement, conserver la valeur précédente et la restaurer après l'opération ; ne changez pas un mode en même temps à partir de plusieurs procédures.
- Les pas de virage et de déviation sont différents des mouvements normaux. La confirmation du serveur, les retards de communication et les obstacles peuvent augmenter le temps réel. Le client n'envoie pas une série d'étapes accélérées pour rattraper les images manquantes.
Chaque exemple peut être enregistré dans un fichier séparé .csx et exécuté dans IDE. Les fonctions d'objet UO et d'attente fournissent l'hôte de la session de jeu en cours. Remplacez les noms, coordonnées et adresses de la démo serial par les vôtres.
Exécutez ce code dans un fichier .csx séparé. Les arguments sont visibles dans l’appel ; remplacez les noms, serials et adresses d’exemple par les vôtres.
Le résultat d’un seul appel est affiché dans le journal. Un nombre n’est pas converti en bool ; un tableau est affiché par son nombre d’éléments.
object? result = UO.GetRunUnMountTimer();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Paramètres et déroulement de l’exécution :
- UO.GetRunUnmountTimer() est appelé sans arguments. delayMs - intervalle de course à pied ; les autres modes ne sont pas mesurés ici.
var delayMs = UO.GetRunUnMountTimer();
UO.Print("Movement delay, ms: " + Convert.ToString(delayMs));Paramètres et déroulement de l’exécution :
- steps=5 est le nombre d'étapes à évaluer, pas un paramètre de commande. La multiplication donne uniquement la contribution des délais configurés ; il ne s'agit pas d'une promesse d'heure d'arrivée ou d'un délai d'attente d'itinéraire.
return RunScenario();
object? RunScenario()
{
var steps = 5;
var delayMs = UO.GetRunUnMountTimer();
var estimateMs = steps * delayMs;
UO.Print("Step-delay budget, ms: " + Convert.ToString(estimateMs));
return null;
}Paramètres et déroulement de l’exécution :
- précédent est comparé à 200 ms. L'intervalle standard est défini, les trois autres modes sont enregistrés. Le personnage ne bouge pas du défi lui-même.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
var previous = UO.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;
}C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Paramètres: Aucun paramètre.
Résultat: dynamic / Any.
Pendant un appel:
Code interne de l’implémentation ; ce n’est pas un script autonome.
case "getrununmounttimer": return new InjectionValue(state.RunUnmountTimer);Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.GetWalkMountTimer();Affiche l'intervalle configuré d'un pas de marche à cheval en millisecondes. Utile pour vérifier le mode, estimer le timing et enregistrer le réglage avant de ralentir temporairement.
Il n'y a pas de paramètres.
int de 200 à 2000 inclus - intervalle configuré en millisecondes. La valeur par défaut est 200. Il s'agit du nombre de fois, pas de true/false, ni de ID, et non du nombre de cellules passées.
- Le réglage s'applique au mode de conduite. La valeur standard et minimale autorisée est 200 ms ; la limite supérieure est 2000 ms. Les trois autres modes ont des paramètres distincts.
- Il s'agit de l'intervalle de mouvement local du personnage, et non du ping, du FPS, du délai d'attente de recherche de chemin ou de la durée mesurée des étapes du serveur. Augmenter le nombre ralentit le mouvement ; diminuer en dessous de l'intervalle standard n'accélère pas l'envoi des paquets.
- L'équipe elle-même ne commence pas à bouger, ne monte pas sur la monture et ne change pas le mode marche/course. Le mode est sélectionné pendant la conduite ; le mode de vitesse et le vol spécifiés par le serveur sont également pris en compte par le client.
- Le paramétrage est général pour le déplacement de ce client : il peut être utilisé par le contrôle manuel, la carte d'itinéraire et d'autres scripts. En le modifiant temporairement, conserver la valeur précédente et la restaurer après l'opération ; ne changez pas un mode en même temps à partir de plusieurs procédures.
- Les pas de virage et de déviation sont différents des mouvements normaux. La confirmation du serveur, les retards de communication et les obstacles peuvent augmenter le temps réel. Le client n'envoie pas une série d'étapes accélérées pour rattraper les images manquantes.
- Dans un hôte client standard, ces données d'état sont extraites du gestionnaire GetPersistentState et sont communes aux scripts/chat/macros du même monde/profil, et n'appartiennent pas à un seul script. Un autre processus ou un InjectionRuntimeState apparemment séparé a un état différent. Charger/effacer un profil peut le remplacer ; Les serial enregistrés sont toujours comparés au monde chargé.
Chaque exemple peut être enregistré dans un fichier séparé .csx et exécuté dans IDE. Les fonctions d'objet UO et d'attente fournissent l'hôte de la session de jeu en cours. Remplacez les noms, coordonnées et adresses de la démo serial par les vôtres.
Exécutez ce code dans un fichier .csx séparé. Les arguments sont visibles dans l’appel ; remplacez les noms, serials et adresses d’exemple par les vôtres.
Le résultat d’un seul appel est affiché dans le journal. Un nombre n’est pas converti en bool ; un tableau est affiché par son nombre d’éléments.
object? result = UO.GetWalkMountTimer();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Paramètres et déroulement de l’exécution :
- UO.GetWalkMountTimer() est appelé sans arguments. delayMs — intervalle de marche à cheval ; les autres modes ne sont pas mesurés ici.
var delayMs = UO.GetWalkMountTimer();
UO.Print("Movement delay, ms: " + Convert.ToString(delayMs));Paramètres et déroulement de l’exécution :
- steps=5 est le nombre d'étapes à évaluer, pas un paramètre de commande. La multiplication donne uniquement la contribution des délais configurés ; il ne s'agit pas d'une promesse d'heure d'arrivée ou d'un délai d'attente d'itinéraire.
return RunScenario();
object? RunScenario()
{
var steps = 5;
var delayMs = UO.GetWalkMountTimer();
var estimateMs = steps * delayMs;
UO.Print("Step-delay budget, ms: " + Convert.ToString(estimateMs));
return null;
}Paramètres et déroulement de l’exécution :
- précédent est comparé à 200 ms. L'intervalle standard est défini, les trois autres modes sont enregistrés. Le personnage ne bouge pas du défi lui-même.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
var previous = UO.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;
}C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Paramètres: Aucun paramètre.
Résultat: dynamic / Any.
Pendant un appel:
Code interne de l’implémentation ; ce n’est pas un script autonome.
case "getwalkmounttimer": return new InjectionValue(state.WalkMountTimer);Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.GetWalkUnmountTimer();Affiche l'intervalle configuré d'un pas de marche en millisecondes. Utile pour vérifier le mode, estimer le timing et enregistrer le réglage avant de ralentir temporairement.
Il n'y a pas de paramètres.
int de 400 à 2000 inclus - intervalle configuré en millisecondes. La valeur par défaut est 400. Il s'agit du nombre de fois, pas de true/false, ni de ID, et non du nombre de cellules passées.
- Le réglage s'applique au mode marche. La valeur standard et minimale autorisée est 400 ms ; la limite supérieure est 2000 ms. Les trois autres modes ont des paramètres distincts.
- Il s'agit de l'intervalle de mouvement local du personnage, et non du ping, du FPS, du délai d'attente de recherche de chemin ou de la durée mesurée des étapes du serveur. Augmenter le nombre ralentit le mouvement ; diminuer en dessous de l'intervalle standard n'accélère pas l'envoi des paquets.
- L'équipe elle-même ne commence pas à bouger, ne monte pas sur la monture et ne change pas le mode marche/course. Le mode est sélectionné pendant la conduite ; le mode de vitesse et le vol spécifiés par le serveur sont également pris en compte par le client.
- Le paramétrage est général pour le déplacement de ce client : il peut être utilisé par le contrôle manuel, la carte d'itinéraire et d'autres scripts. En le modifiant temporairement, conserver la valeur précédente et la restaurer après l'opération ; ne changez pas un mode en même temps à partir de plusieurs procédures.
- Les pas de virage et de déviation sont différents des mouvements normaux. La confirmation du serveur, les retards de communication et les obstacles peuvent augmenter le temps réel. Le client n'envoie pas une série d'étapes accélérées pour rattraper les images manquantes.
- Dans un hôte client standard, ces données d'état sont extraites du gestionnaire GetPersistentState et sont communes aux scripts/chat/macros du même monde/profil, et n'appartiennent pas à un seul script. Un autre processus ou un InjectionRuntimeState apparemment séparé a un état différent. Charger/effacer un profil peut le remplacer ; Les serial enregistrés sont toujours comparés au monde chargé.
Chaque exemple peut être enregistré dans un fichier séparé .csx et exécuté dans IDE. Les fonctions d'objet UO et d'attente fournissent l'hôte de la session de jeu en cours. Remplacez les noms, coordonnées et adresses de la démo serial par les vôtres.
Exécutez ce code dans un fichier .csx séparé. Les arguments sont visibles dans l’appel ; remplacez les noms, serials et adresses d’exemple par les vôtres.
Le résultat d’un seul appel est affiché dans le journal. Un nombre n’est pas converti en bool ; un tableau est affiché par son nombre d’éléments.
object? result = UO.GetWalkUnmountTimer();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Paramètres et déroulement de l’exécution :
- UO.GetWalkUnmountTimer() est appelé sans arguments. delayMs — intervalle de marche ; les autres modes ne sont pas mesurés ici.
var delayMs = UO.GetWalkUnmountTimer();
UO.Print("Movement delay, ms: " + Convert.ToString(delayMs));Paramètres et déroulement de l’exécution :
- steps=5 est le nombre d'étapes à évaluer, pas un paramètre de commande. La multiplication donne uniquement la contribution des délais configurés ; il ne s'agit pas d'une promesse d'heure d'arrivée ou d'un délai d'attente d'itinéraire.
return RunScenario();
object? RunScenario()
{
var steps = 5;
var delayMs = UO.GetWalkUnmountTimer();
var estimateMs = steps * delayMs;
UO.Print("Step-delay budget, ms: " + Convert.ToString(estimateMs));
return null;
}Paramètres et déroulement de l’exécution :
- précédent est comparé à 400 ms. L'intervalle standard est défini, les trois autres modes sont enregistrés. Le personnage ne bouge pas du défi lui-même.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
var previous = UO.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;
}C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Paramètres: Aucun paramètre.
Résultat: dynamic / Any.
Pendant un appel:
Code interne de l’implémentation ; ce n’est pas un script autonome.
case "getwalkunmounttimer": return new InjectionValue(state.WalkUnmountTimer);Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.IsMoving();Vérifie le mouvement de votre personnage.
Il n'y a pas de paramètres.
int bool (1/0) : 1 - Pathfinder automatique est actif ou il y a encore des étapes dans la file d'attente du personnage ; 0 - les deux sont manquants ou le personnage n'est pas chargé. Ce n'est pas une confirmation de l'atteinte d'un objectif ou du nombre d'étapes.
Le résultat de la commande est un indicateur numérique : 1 signifie une condition remplie, 0 signifie une condition non remplie. Après var result = command(...) vérifiez si (result != 0) ou if (result == 0). Enregistrez le résultat d'un appel : un appel répété peut effectuer à nouveau l'action ou lire l'état qui a déjà changé.
- Les données locales déjà reçues sont lues. La requête n'ouvre pas le statut et n'oblige pas le serveur à envoyer une mise à jour. Après un décès, une transition de map ou une suppression d'objet, les valeurs peuvent changer entre deux appels.
- C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Chaque exemple peut être enregistré dans un fichier séparé .csx et exécuté dans IDE. Les fonctions d'objet UO et d'attente fournissent l'hôte de la session de jeu en cours. Remplacez les noms, coordonnées et adresses de la démo serial par les vôtres.
Exécutez ce code dans un fichier .csx séparé. Les arguments sont visibles dans l’appel ; remplacez les noms, serials et adresses d’exemple par les vôtres.
Le résultat d’un seul appel est affiché dans le journal. Un nombre n’est pas converti en bool ; un tableau est affiché par son nombre d’éléments.
var result = UO.IsMoving();
UO.Print("IsMoving: " + Convert.ToString(result));Paramètres et déroulement de l’exécution :
- Les parenthèses vides indiquent self. actif — numéro 1 ou 0 ; Le texte du message sert d'exemple de traitement de branchement.
- 1 - Pathfinder automatique est actif ou il y a encore des étapes dans la file d'attente du personnage ; 0 - les deux sont manquants ou le personnage n'est pas chargé. Ce n'est pas une confirmation de l'atteinte d'un objectif ou du nombre d'étapes.
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;Paramètres et déroulement de l’exécution :
- La commande n'a pas d'argument objet : même après Exists(self), elle ne lit que son propre état.
- Exists(self) vérifie la charge du joueur séparément du drapeau demandé. Le monde peut changer entre les contrôles.
return RunScenario();
object? RunScenario()
{
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;Paramètres et déroulement de l’exécution :
- Les deux appels sans arguments se lisent self ; UO.Wait(500) - faites une pause d'une demi-seconde.
- Deux instantanés de drapeau sont comparés. Les transitions entre les prises de vue peuvent être ignorées ; ce n'est pas un abonnement à tous les événements du serveur.
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;
}C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Paramètres: Aucun paramètre.
Résultat: int / Integer.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.IsMoving. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.IsMoving:bridge.IsMoving().
Code interne de l’implémentation ; ce n’est pas un script autonome.
public int IsMoving() => bridge.IsMoving();Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.IsRunning(object? objID);Vérifie le drapeau en marche dans la dernière direction connue du mobile.
-
objID— Obligatoire serial/ID d'un objet spécifique : int, chaîne hexadécimale ou alias self, backpack, lasttarget, lastobject, lastcontainer, laststatus, finditem, lastcorpse ou nom AddObject. Ce n'est pas graphic/type. Le nom non spécifié se résout en 0 ; la commande n'ouvre aucune nouvelle cible. L'argument est requis; pour vous-même, passez self.
int 1 - mobile chargé a l'attribut Direction.Running. int 0 - l'attribut est manquant, l'objet n'est pas mobile, inconnu ou supprimé. Le dernier drapeau en marche peut être conservé après l'arrêt. Il ne s'agit pas de l'activité du parcours, ni de la vitesse ou du nombre de pas restants. Pour déplacer self, utilisez également Moving().
Le résultat de la commande est un indicateur numérique : 1 signifie une condition remplie, 0 signifie une condition non remplie. Après var result = command(...) vérifiez si (result != 0) ou if (result == 0). Enregistrez le résultat d'un appel : un appel répété peut effectuer à nouveau l'action ou lire l'état qui a déjà changé.
- Le modèle client local est lu ; Il n'y a aucune requête au serveur, pas d'attente ni de déplacement.
- Le résultat fait référence au moment de la lecture. Après UO.Wait ou une autre action, l'objet et ses drapeaux peuvent changer.
- Le dernier drapeau en marche peut être conservé après l'arrêt. Il ne s'agit pas de l'activité du parcours, ni de la vitesse ou du nombre de pas restants. Pour déplacer self, utilisez également Moving().
Chaque exemple peut être enregistré dans un fichier séparé .csx et exécuté dans IDE. Les fonctions d'objet UO et d'attente fournissent l'hôte de la session de jeu en cours. Remplacez les noms, coordonnées et adresses de la démo serial par les vôtres.
Exécutez ce code dans un fichier .csx séparé. Les arguments sont visibles dans l’appel ; remplacez les noms, serials et adresses d’exemple par les vôtres.
Le résultat d’un seul appel est affiché dans le journal. Un nombre n’est pas converti en bool ; un tableau est affiché par son nombre d’éléments.
var result = UO.IsRunning("self");
UO.Print("IsRunning: " + Convert.ToString(result));Paramètres et déroulement de l’exécution :
- L'argument self sélectionne explicitement son caractère. état - 1/0 uniquement.
- Le dernier drapeau en marche peut être conservé après l'arrêt. Il ne s'agit pas de l'activité du parcours, ni de la vitesse ou du nombre de pas restants. Pour déplacer self, utilisez également 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));Paramètres et déroulement de l’exécution :
- IsNpc exclut le sujet et l'objet inconnu. target stocke un seul serial plutôt qu'une référence en direct à un lasttarget changeant.
- Le résultat fait référence au champ Direction.Running. Les données ne sont mises à jour qu'une fois que le client a reçu l'état approprié.
return RunScenario();
object? RunScenario()
{
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;Paramètres et déroulement de l’exécution :
- UO.Wait(500) — pause en millisecondes. Après cela, il est vérifié séparément que mobile existe toujours.
- Deux photographies sont comparées. Des modifications intermédiaires peuvent être manquées, et il ne s'agit pas d'un abonnement continu aux événements du serveur.
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;
}C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Paramètres: objID (Any)
Résultat: int / Integer.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetRun:bridge.GetRun(Arg(0, bridge.Self)). -
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg:Arg(0, bridge.Self). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self:bridge.Self.
Code interne de l’implémentation ; ce n’est pas un script autonome.
case "isrunning": return new InjectionValue(bridge.GetRun(Arg(0, bridge.Self)));Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.LastStepQUsedDoor();
dynamic UO.LastStepQUsedDoor(object? value);Lit ou modifie manuellement l'indicateur de tentative d'ouverture de porte de la dernière commande StepQ.
-
value— Entier facultatif. Exactement ce numéro est stocké avec l'argument ; sans argument, la lecture est effectuée.
int — marque enregistrée. L'habituel StepQ le réinitialise à 0 et, lorsque moveOpenDoor est activé, enregistre le résultat de TryOpenDoorForStep : 1 si une tentative est détectée, 0 sinon. Le formulaire manuel autorise d'autres numéros. Il ne s'agit pas d'une porte serial ni d'une confirmation de son ouverture.
- Le contrôle ne lit pas l'état de la porte sur le serveur. L'appel de secours OpenDoor ne modifie pas le top zéro.
- Si StepQ échoue prématurément en raison de la connexion/endurance, la réinitialisation n'est pas encore effectuée, donc la valeur précédente peut rester.
- Dans un hôte client standard, ces données d'état sont extraites du gestionnaire GetPersistentState et sont communes aux scripts/chat/macros du même monde/profil, et n'appartiennent pas à un seul script. Un autre processus ou un InjectionRuntimeState apparemment séparé a un état différent. Charger/effacer un profil peut le remplacer ; Les serial enregistrés sont toujours comparés au monde chargé.
Chaque exemple peut être enregistré dans un fichier séparé .csx et exécuté dans IDE. Les fonctions d'objet UO et d'attente fournissent l'hôte de la session de jeu en cours. Remplacez les noms, coordonnées et adresses de la démo serial par les vôtres.
Exécutez ce code dans un fichier .csx séparé. Les arguments sont visibles dans l’appel ; remplacez les noms, serials et adresses d’exemple par les vôtres.
Le résultat d’un seul appel est affiché dans le journal. Un nombre n’est pas converti en bool ; un tableau est affiché par son nombre d’éléments.
object? result = UO.LastStepQUsedDoor();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Paramètres et déroulement de l’exécution :
- Sans arguments, le numéro stocké est lu.
- Ne l'utilisez pas comme ID pour UseObject.
UO.Print(Convert.ToString(UO.LastStepQUsedDoor()));Paramètres et déroulement de l’exécution :
- value=0 efface la marque précédente. direction=2 — E; run=false.
- Le résultat StepQ et la marque de porte ont des significations différentes.
return RunScenario();
object? RunScenario()
{
UO.LastStepQUsedDoor(0);
var status = UO.StepQ(2, false);
UO.Print(Convert.ToString(UO.LastStepQUsedDoor()));
return null;
}Paramètres et déroulement de l’exécution :
- précédent : valeur enregistrée.
- La récupération manuelle n'effectue aucune action sur la porte.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
var previous = UO.LastStepQUsedDoor();
UO.LastStepQUsedDoor(0);
UO.Print(Convert.ToString(UO.LastStepQUsedDoor()));
UO.LastStepQUsedDoor(previous);
return null;
}
}C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Paramètres: Aucun paramètre.
Résultat: dynamic / Any.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg:Arg(0).
Code interne de l’implémentation ; ce n’est pas un script autonome.
case "laststepquseddoor":
if (arguments.Length > 0) state.LastStepUsedDoor = Arg(0);
return new InjectionValue(state.LastStepUsedDoor);Paramètres: value (Any)
Résultat: dynamic / Any.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg:Arg(0).
Code interne de l’implémentation ; ce n’est pas un script autonome.
case "laststepquseddoor":
if (arguments.Length > 0) state.LastStepUsedDoor = Arg(0);
return new InjectionValue(state.LastStepUsedDoor);Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.Move();Lit s'il existe un itinéraire automatique ou des étapes de caractère qui ne sont pas encore terminées.
Il n'y a pas de paramètres.
int 1 — Pathfinder est actif ou des étapes restent dans la file d'attente d'animation des personnages ; 0 - les deux sont manquants ou le personnage n'est pas chargé. Il ne s'agit pas du nombre de pas, du résultat de l'atteinte d'un objectif précédent ou du signe de tenir la souris.
Le résultat de la commande est un indicateur numérique : 1 signifie une condition remplie, 0 signifie une condition non remplie. Après var result = command(...) vérifiez si (result != 0) ou if (result == 0). Enregistrez le résultat d'un appel : un appel répété peut effectuer à nouveau l'action ou lire l'état qui a déjà changé.
- La commande lit uniquement l'état. Si le résultat est différent de zéro, le timer compatible TicksAnim est mis à jour. Les étapes demandées par la souris/les touches sont également comptées tant qu'elles restent dans la file d'attente.
- Pour arrêter l'itinéraire automatique, utilisez MoverStop. MoveOff contrôle d'autres étapes du clavier.
Chaque exemple peut être enregistré dans un fichier séparé .csx et exécuté dans IDE. Les fonctions d'objet UO et d'attente fournissent l'hôte de la session de jeu en cours. Remplacez les noms, coordonnées et adresses de la démo serial par les vôtres.
Exécutez ce code dans un fichier .csx séparé. Les arguments sont visibles dans l’appel ; remplacez les noms, serials et adresses d’exemple par les vôtres.
Le résultat d’un seul appel est affiché dans le journal. Un nombre n’est pas converti en bool ; un tableau est affiché par son nombre d’éléments.
var result = UO.Move();
UO.Print("Move: " + Convert.ToString(result));Paramètres et déroulement de l’exécution :
- Il n'y a pas d'arguments.
- 0 ne prouve pas que l'objectif a été atteint : le parcours aurait pu être annulé.
UO.Print("Movement active or queued: " + Convert.ToString(UO.Move()));Paramètres et déroulement de l’exécution :
- 100 attend plus de 50 ms définit la limite approximative de 5 secondes.
- L'exécution de cette vérification ne démarre ni n'arrête le mouvement.
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;Paramètres et déroulement de l’exécution :
- Move() vérifie l'activité, MoverStop() supprime la route.
- Les paquets déjà envoyés peuvent toujours être confirmés par le serveur.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
if (Truth(UO.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;
}C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Paramètres: Aucun paramètre.
Résultat: int / Integer.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.Move. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Move:bridge.Move(). -
InjectionScript.Runtime.InjectionApiUO.Timer:Timer().
Code interne de l’implémentation ; ce n’est pas un script autonome.
public int Move()
{
int result = bridge.Move();
if (result != 0)
ticksAnim = Timer();
return result;
}Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.MoveOff();Désactive les étapes clés PMove compatibles.
Il n'y a pas de paramètres.
void - aucune valeur de retour. Appelez sur une ligne séparée ; ce n'est pas true/false ou le nombre d'étapes.
- Modifie l'indicateur MoveEnabled dans l'état d'exécution. Il ne s'agit pas d'un verrouillage de caractères universel : NewMoveXY, MoveXYZ, Step et la souris ne sont pas contrôlés par ce flag.
- MoveOff n'arrête pas un Pathfinder déjà en cours d'exécution ; cela nécessite MoverStop.
- Dans un hôte client standard, ces données d'état sont extraites du gestionnaire GetPersistentState et sont communes aux scripts/chat/macros du même monde/profil, et n'appartiennent pas à un seul script. Un autre processus ou un InjectionRuntimeState apparemment séparé a un état différent. Charger/effacer un profil peut le remplacer ; Les serial enregistrés sont toujours comparés au monde chargé.
Chaque exemple peut être enregistré dans un fichier séparé .csx et exécuté dans IDE. Les fonctions d'objet UO et d'attente fournissent l'hôte de la session de jeu en cours. Remplacez les noms, coordonnées et adresses de la démo serial par les vôtres.
Exécutez ce code dans un fichier .csx séparé. Les arguments sont visibles dans l’appel ; remplacez les noms, serials et adresses d’exemple par les vôtres.
La commande forme une instruction séparée. Le message précédent indique le début de l’appel et ne confirme aucune action du serveur.
UO.Print("Calling UO.MoveOff");
UO.MoveOff();Paramètres et déroulement de l’exécution :
- Il n'y a pas d'arguments.
- L'indicateur PMove est modifié, sans valeur de retour.
UO.MoveOff();Paramètres et déroulement de l’exécution :
- MoveOn active les étapes clés avant PMove ; MoveOff s'éteint après son achèvement normal.
- Ce sont des commandes séquentielles ; un indicateur désactivé ne signifie pas un arrêt d'urgence pour toutes les procédures.
return RunScenario();
object? RunScenario()
{
UO.MoveOn();
UO.PMove(UO.GetX() + 1, UO.GetY());
UO.MoveOff();
return null;
}Paramètres et déroulement de l’exécution :
- Les deux équipes contrôlent des mécanismes de mouvement différents.
- Move() lit l'itinéraire automatique ; ne considérez pas cela comme un test de MoveEnabled.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
UO.MoveOff();
UO.MoverStop();
UO.Print(Convert.ToString(UO.Move()));
return null;
}
}C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Paramètres: Aucun paramètre.
Résultat: void / Unit.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.MoveOff. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.EnableMove:bridge.EnableMove(false).
Code interne de l’implémentation ; ce n’est pas un script autonome.
public void MoveOff() => bridge.EnableMove(false);Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.MoveOn();Active les étapes clés PMove compatibles.
Il n'y a pas de paramètres.
void - aucune valeur de retour. Appelez sur une ligne séparée ; ce n'est pas true/false ou le nombre d'étapes.
- Modifie l'indicateur MoveEnabled dans l'état d'exécution. Il ne s'agit pas d'un verrouillage de caractères universel : NewMoveXY, MoveXYZ, Step et la souris ne sont pas contrôlés par ce flag.
- MoveOff n'arrête pas un Pathfinder déjà en cours d'exécution ; cela nécessite MoverStop.
- Dans un hôte client standard, ces données d'état sont extraites du gestionnaire GetPersistentState et sont communes aux scripts/chat/macros du même monde/profil, et n'appartiennent pas à un seul script. Un autre processus ou un InjectionRuntimeState apparemment séparé a un état différent. Charger/effacer un profil peut le remplacer ; Les serial enregistrés sont toujours comparés au monde chargé.
Chaque exemple peut être enregistré dans un fichier séparé .csx et exécuté dans IDE. Les fonctions d'objet UO et d'attente fournissent l'hôte de la session de jeu en cours. Remplacez les noms, coordonnées et adresses de la démo serial par les vôtres.
Exécutez ce code dans un fichier .csx séparé. Les arguments sont visibles dans l’appel ; remplacez les noms, serials et adresses d’exemple par les vôtres.
La commande forme une instruction séparée. Le message précédent indique le début de l’appel et ne confirme aucune action du serveur.
UO.Print("Calling UO.MoveOn");
UO.MoveOn();Paramètres et déroulement de l’exécution :
- Il n'y a pas d'arguments.
- L'indicateur PMove est modifié, sans valeur de retour.
UO.MoveOn();Paramètres et déroulement de l’exécution :
- MoveOn active les étapes clés avant PMove ; MoveOff s'éteint après son achèvement normal.
- Ce sont des commandes séquentielles ; un indicateur désactivé ne signifie pas un arrêt d'urgence pour toutes les procédures.
return RunScenario();
object? RunScenario()
{
UO.MoveOn();
UO.PMove(UO.GetX() + 1, UO.GetY());
UO.MoveOff();
return null;
}Paramètres et déroulement de l’exécution :
- MoveOn active les étapes clés PMove compatibles et ne renvoie pas de valeur. Le résultat du mouvement est vérifié par les coordonnées ; MoveOn ne contrôle pas tous les modes de déplacement.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
UO.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;
}
}C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Paramètres: Aucun paramètre.
Résultat: void / Unit.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.MoveOn. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.EnableMove:bridge.EnableMove(true).
Code interne de l’implémentation ; ce n’est pas un script autonome.
public void MoveOn() => bridge.EnableMove(true);Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
dynamic UO.MoveXY(object? xdst, object? ydst, object? optimized, object? accuracy, object? running);Déplace le personnage vers X/Y avec cinq paramètres requis et attend le résultat.
-
xdst— Coordonnée mondiale X de la destination, 0..65535. Ce n'est pas serial ou une position à l'intérieur d'un gump. -
ydst— Coordonnée mondiale Y de la destination, 0..65535. -
optimized- true - mode normal de recherche et de vérification du chemin à suivre ; false - heuristique réduite et vérification du pas le plus proche. false ne désactive pas l'évitement d'obstacles. -
accuracy— Tolérance pour X et Y dans les cellules : les deux écarts doivent s'y adapter. La valeur est limitée à la plage 0..20 ; 0 nécessite un X/Y précis. -
running- true/1 - requête d'exécution, false/0 - étape. Les retards de mouvement du serveur persistent ; Ce n'est pas un multiplicateur de vitesse.
int 1 - à la fin du contrôle le personnage est dans la tolérance donnée X/Y/Z, y compris lorsqu'il y était déjà avant le défi. int 0 - coordonnées invalides, échec de lancement, point non atteint ou condition d'arrêt déclenchée. Ce n'est pas le nombre d'étapes ou serial ; En cas d'annulation d'urgence, la procédure est interrompue au lieu de revenir normalement 0.
Le résultat de la commande est un indicateur numérique : 1 signifie une condition remplie, 0 signifie une condition non remplie. Après var result = command(...) vérifiez si (result != 0) ou if (result == 0). Enregistrez le résultat d'un appel : un appel répété peut effectuer à nouveau l'action ou lire l'état qui a déjà changé.
- La route A* complète est construite avant la première étape, par courtes portions entre les mises à jour du client. Lorsque Optimized=true les cellules 4 suivantes du chemin sont vérifiées ; lorsque false est le pas le plus proche. Il s'agit d'une vérification du chemin déjà calculé, et non de la distance de l'ensemble de l'itinéraire ni des curseurs de détour lors du déplacement de la souris.
- Une panne du serveur DenyWalk ou un nouvel obstacle demande un recalcul à partir de la position actuelle après avoir terminé la file d'attente des étapes. Le nombre de répétitions et la fréquence des recalculs sont limités ; aucun chemin ne peut terminer le mouvement par 0.
- L'itinéraire appartient à la procédure qui l'a démarré : son arrêt d'urgence annule le trajet automatique restant. Si un autre parcours ou un autre utilisateur a déjà remplacé l'itinéraire, l'annulation du propriétaire précédent n'affecte pas le nouvel itinéraire. Les étapes déjà envoyées ne sont pas rappelées.
- SetBadLocation et SetBadObject sont utilisés comme instantané des interdictions du runtime actuel lorsque la route est démarrée. Ils sont sauvegardés lors de son recalcul interne. La modification ou l'effacement des listes affecte l'itinéraire suivant, plutôt que d'écraser celui déjà en cours.
- Après avoir accepté la demande, l'appel attend sur le fil de script. La recherche et le recalcul initiaux sont effectués sur le flux de jeu par morceaux : un maximum d'expansion de nœud 32 et un budget souple d'environ 1 ms par morceau. Une vérification complexe de cellule ou une lecture de carte peut dépasser ce budget. Entre les portions, le client continue de mettre à jour ; la limite totale de recherche reste 10000 nœuds.
- le délai d'attente est compté une fois la demande acceptée et inclut les parties ultérieures de recherche et de recalcul. stopOnStuck ne considère pas une recherche en cours comme un caractère bloqué ; Une fois la planification terminée, aucun changement de position n'est à nouveau pris en compte. Le 1/0 final vérifie les coordonnées réelles, pas seulement l'état de préparation du chemin.
- Le résultat prend en compte la position locale du client ; une correction ultérieure du serveur est toujours possible. L'exécution de commandes de mouvement concurrentes à partir de différentes routines modifie l'itinéraire global du personnage.
- Les paramètres moveCheckStamina, moveExitOnDisconnect, moveOpenDoor, moveThroughCorner, moveThroughNPC, moveHeuristicMult, moveTurnCost et moveBetweenTwoCorners affectent les performances. avoidMobiles/openDoors explicite remplacent les valeurs correspondantes pour cet appel.
- Le résultat 0 n'indique pas la cause exacte. Vérifiez les coordonnées, la connexion, l'endurance et le journal ; ne répétez pas le mouvement à l'infini sans UO.Wait et une limite de tentatives.
- La cible Z est prise à l'appel, tolérance Z=255. Pour des restrictions supplémentaires, utilisez NewMoveXY ; pour sélectionner la hauteur - MoveXYZ.
- Le pont principal enregistre le numéro de demande, les instances de joueur/Pathfinder/carte et l'index de la carte. Une nouvelle demande, un changement de contexte ou un refus définitif donne 0 ; la vérification est répétée après la lecture des coordonnées et le dernier rappel. Timeout, maxSteps et callback=0 arrêtent uniquement la requête enregistrée, pas une nouvelle route étrangère. Le Bloqué Temporaire, alors que la récupération est toujours active, ne perd pas la possession : l'attente continue. Pour les ponts hérités externes sans IApiMovementOwnershipBridge, le mécanisme compatible précédent est conservé.
- Le Pathfinder général stocke jusqu'à 8 interdictions directionnelles temporaires X/Y/Z pendant 2000 ms, uniquement en cas de mouvement rejeté de la requête active correspondante. La rotation, la séquence inconnue, la resynchronisation et la demande ancienne/étrangère ne créent pas une telle interdiction. Une nouvelle requête externe et la perte du contexte de la carte/du lecteur les effacent. La recherche de géométrie chargée tente de contourner la transition ; il ne s'agit pas de connaître tous les obstacles du serveur. Sans changer les X/Y/Z du lecteur, jusqu'à 8 recalculs internes sont autorisés avec une pause d'au moins 40 ms. Il n'y a pas de parcours complet ou ce budget est épuisé - le parcours se termine. La tâche de coordination se termine ensuite après avoir traité les étapes soumises ; mobile-Follow peut réessayer en raison de son retard.
Chaque exemple peut être enregistré dans un fichier séparé .csx et exécuté dans IDE. Les fonctions d'objet UO et d'attente fournissent l'hôte de la session de jeu en cours. Remplacez les noms, coordonnées et adresses de la démo serial par les vôtres.
Exécutez ce code dans un fichier .csx séparé. Les arguments sont visibles dans l’appel ; remplacez les noms, serials et adresses d’exemple par les vôtres.
Le résultat d’un seul appel est affiché dans le journal. Un nombre n’est pas converti en bool ; un tableau est affiché par son nombre d’éléments.
object? result = UO.MoveXY(UO.GetX() + 2, UO.GetY(), true, 0, false);
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));Paramètres et déroulement de l’exécution :
- Xdst - deux cellules à l'est ; Ydst ne change pas.
- Optimisé=true, Précision=0, Running=false. L'appel renvoie le résultat une fois terminé.
var ok = UO.MoveXY(UO.GetX() + 2, UO.GetY(), true, 0, false);
UO.Print(Convert.ToString(ok));Paramètres et déroulement de l’exécution :
- Xdst/Ydst sont lus à partir de l'objet sélectionné ; ce doit être un objet du monde, pas un objet à l'intérieur du conteneur.
- Accuracy=1 vous permet de vous rapprocher ; En cours d'exécution=true. Les hauteurs ne se limitent pas à ce défi.
return RunScenario();
object? RunScenario()
{
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;Paramètres et déroulement de l’exécution :
- Remplacez la cible 1445/1690 par la vôtre. Le seuil d'endurance est défini par un paramètre distinct, et non par le sixième paramètre MoveXY.
- Après un retour normal, la valeur d'origine est restaurée. Si un abandon se produit, aucune autre ligne n'est exécutée.
Intervalle minimum de pas : marche - marche 400 ms, course 200 ms ; équitation - marche 200 ms, course 100 ms.
Il s'agit de limites client standard et non de paramètres automatiquement définis pour votre partition. La vitesse du serveur et les modes de vol sont comptés séparément. Les minuteries de script peuvent ralentir le mouvement, mais ne réduisent pas ces limites.
Les étapes, les itinéraires, Follow, les commandes souris/touches et la carte utilisent la file d'attente partagée du personnage. Le remplacement de l'itinéraire, le virage ou l'ajustement de la position par le serveur n'annule pas la pause restante après la demande d'étape. Après le délai, il n'y a pas de rafale rapide pour compenser les images perdues. L’attente de confirmation, les obstacles et une mauvaise communication peuvent ralentir le mouvement.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
var previous = UO.moveCheckStamina();
UO.moveCheckStamina(15);
var ok = UO.MoveXY(1445, 1690, true, 0, false);
UO.moveCheckStamina(previous);
UO.Print(Convert.ToString(ok));
return null;
}
}C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Paramètres: xdst (Any), ydst (Any), optimized (Any), accuracy (Any), running (Any)
Résultat: dynamic / Any.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::MoveTo:MoveTo(Arg(0), Arg(1), bridge.GetZ(bridge.Self), Arg(3), Arg(4) != 0, 255, Arg(2) != 0). -
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg:Arg(0). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetZ:bridge.GetZ(bridge.Self). -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self:bridge.Self.
Code interne de l’implémentation ; ce n’est pas un script autonome.
case "movexy":
return new InjectionValue(MoveTo(Arg(0), Arg(1), bridge.GetZ(bridge.Self), Arg(3), Arg(4) != 0, 255, Arg(2) != 0));Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.MoveXYZ(object? x, object? y, object? z, object? accuracyXY, object? accuracyZ, object? running);
int UO.MoveXYZ(object? x, object? y, object? z, object? accuracyXY, object? accuracyZ, object? running, object? timeout);
int UO.MoveXYZ(object? x, object? y, object? z, object? accuracyXY, object? accuracyZ, object? running, object? timeout, object? maxSteps);
int UO.MoveXYZ(object? x, object? y, object? z, object? accuracyXY, object? accuracyZ, object? running, object? timeout, object? maxSteps, object? avoidMobiles);
int UO.MoveXYZ(object? x, object? y, object? z, object? accuracyXY, object? accuracyZ, object? running, object? timeout, object? maxSteps, object? avoidMobiles, object? openDoors);Déplace le personnage vers un point du monde avec des tolérances horizontales et verticales distinctes.
-
x- Obligatoire int : coordonnées mondiales de la destination X, 0..65535, sur la carte actuelle. Pas les coordonnées de Gump. -
y- Obligatoire int : coordonnées mondiales de la destination Y, 0..65535, sur la carte actuelle. -
z- Obligatoire int : altitude mondiale cible -128..127. Il s'agit de la hauteur de la surface et non du numéro de l'étage. -
accuracyXY- Obligatoire int. Tolérance pour X et Y dans les cellules : les deux écarts doivent s'y adapter. La valeur est limitée à la plage 0..20 ; 0 nécessite des X/Y précis. -
accuracyZ- Obligatoire int. Tolérance de hauteur : abs (réel Z - requis Z), limité à 0..255. Zéro nécessite une altitude précise ; 255 désactive pratiquement la limitation de Z. -
running— Indicateur booléen obligatoire. true/1 — requête d'exécution, false/0 — étape. Les retards de mouvement du serveur persistent ; Ce n'est pas un multiplicateur de vitesse. -
timeout— Limite d'attente facultative en millisecondes ; un argument manquant, 0 et une valeur négative indiquent l'absence de cette limite supplémentaire. Le compte à rebours commence une fois que l'itinéraire est accepté pour exécution ; il ne s'agit pas d'une limite stricte sur la durée de l'appel complet ainsi que sur la préparation de l'itinéraire. -
maxSteps— Limite facultative des changements de position observés, pas des paquets réseau. 0/négatif/absent - sans cette limite. Il peut y avoir plusieurs étapes entre les sondages, ce n'est donc pas un compteur de cellules précis. -
avoidMobiles— Flag optionnel : true interdit le passage des caractères pris en compte ; false autorise la tentative. Sans argument, moveThroughNPC est utilisé. Le serveur peut toujours refuser l'accès. -
openDoors— Drapeau facultatif pour ouvrir les portes en cours de route. Sans argument, moveOpenDoor est utilisé ; true ne donne pas accès aux portes verrouillées.
int 1 - à la fin du contrôle le personnage est dans la tolérance donnée X/Y/Z, y compris lorsqu'il y était déjà avant le défi. int 0 - coordonnées invalides, échec de lancement, point non atteint ou condition d'arrêt déclenchée. Ce n'est pas le nombre d'étapes ou serial ; En cas d'annulation d'urgence, la procédure est interrompue au lieu de revenir normalement 0.
Le résultat de la commande est un indicateur numérique : 1 signifie une condition remplie, 0 signifie une condition non remplie. Après var result = command(...) vérifiez si (result != 0) ou if (result == 0). Enregistrez le résultat d'un appel : un appel répété peut effectuer à nouveau l'action ou lire l'état qui a déjà changé.
- Comment ça marche, étape 1 : vérification des coordonnées, de la connexion configurée et des conditions d'endurance. Si le personnage se trouve déjà entre accuracyXY et accuracyZ, renvoie immédiatement 1 sans nouvel itinéraire.
- Étape 2 : construit un itinéraire sur la carte actuelle en tenant compte de la hauteur de la surface, des obstacles et des conditions de passage sélectionnées. Le mode optimisé est activé dans la commande ici ; Il n'est pas nécessaire de transmettre un tel paramètre à MoveXYZ.
- Étape 3 : commence à marcher ou à courir le long du parcours et attend le résultat de la procédure en cours. La ligne après l'appel est exécutée une fois celui-ci terminé ; l'interface client continue de fonctionner.
- Étape 4 : Si une étape échoue ou qu'un nouvel obstacle apparaît, le client peut recalculer l'itinéraire à partir de la position actuelle. Les tentatives sont limitées. Lorsqu'un timeout survient ou que la limite des mouvements observables au-delà de la cible est atteinte, le mouvement s'arrête avec 0.
- Étape 5 : Une fois le mouvement terminé, compare le X/Y/Z réel du client avec la cible. Les deux abs(X-x)<=accuracyXY, abs(Y-y)<=accuracyXY et abs(Z-z)<=accuracyZ sont requis. Par exemple, pour la cible 1279/540/20 avec des tolérances 1 et 2 X=1278..1280, Y=539..541 conviennent, Z=18..22.
- La forme minimale contient six arguments : UO.MoveXYZ(1279,540,20,1,2,true). Des arguments supplémentaires sont ajoutés à droite dans le délai d'expiration de l'ordre, maxSteps, avoidMobiles, openDoors. Pour spécifier openDoors, les positions précédentes doivent également être réussies ; les espaces vides entre les virgules ne sont pas pris en charge.
- Différence avec NewMoveXY : MoveXYZ prend la hauteur cible comme troisième argument. NewMoveXY a un troisième argument optimisé ; Vous ne pouvez pas y transférer d'altitude. MoveXYZ n'a pas de rappel dans ce runtime.
- L'itinéraire appartient à la procédure qui l'a démarré : son arrêt d'urgence annule le trajet automatique restant. Si un autre parcours ou un autre utilisateur a déjà remplacé l'itinéraire, l'annulation du propriétaire précédent n'affecte pas le nouvel itinéraire. Les étapes déjà envoyées ne sont pas rappelées.
- SetBadLocation et SetBadObject sont utilisés comme instantané des interdictions du runtime actuel lorsque la route est démarrée. Ils sont sauvegardés lors de son recalcul interne. La modification ou l'effacement des listes affecte l'itinéraire suivant, plutôt que d'écraser celui déjà en cours.
- Après avoir accepté la demande, l'appel attend sur le fil de script. La recherche et le recalcul initiaux sont effectués sur le flux de jeu par morceaux : un maximum d'expansion de nœud 32 et un budget souple d'environ 1 ms par morceau. Une vérification complexe de cellule ou une lecture de carte peut dépasser ce budget. Entre les portions, le client continue de mettre à jour ; la limite totale de recherche reste 10000 nœuds.
- le délai d'attente est compté une fois la demande acceptée et inclut les parties ultérieures de recherche et de recalcul. stopOnStuck ne considère pas une recherche en cours comme un caractère bloqué ; Une fois la planification terminée, aucun changement de position n'est à nouveau pris en compte. Le 1/0 final vérifie les coordonnées réelles, pas seulement l'état de préparation du chemin.
- Le résultat prend en compte la position locale du client ; une correction ultérieure du serveur est toujours possible. L'exécution de commandes de mouvement concurrentes à partir de différentes routines modifie l'itinéraire global du personnage.
- Les paramètres moveCheckStamina, moveExitOnDisconnect, moveOpenDoor, moveThroughCorner, moveThroughNPC, moveHeuristicMult, moveTurnCost et moveBetweenTwoCorners affectent les performances. avoidMobiles/openDoors explicite remplacent les valeurs correspondantes pour cet appel.
- Le résultat 0 n'indique pas la cause exacte. Vérifiez les coordonnées, la connexion, l'endurance et le journal ; ne répétez pas le mouvement à l'infini sans UO.Wait et une limite de tentatives.
- Le pont principal enregistre le numéro de demande, les instances de joueur/Pathfinder/carte et l'index de la carte. Une nouvelle demande, un changement de contexte ou un refus définitif donne 0 ; la vérification est répétée après la lecture des coordonnées et le dernier rappel. Timeout, maxSteps et callback=0 arrêtent uniquement la requête enregistrée, pas une nouvelle route étrangère. Le Bloqué Temporaire, alors que la récupération est toujours active, ne perd pas la possession : l'attente continue. Pour les ponts hérités externes sans IApiMovementOwnershipBridge, le mécanisme compatible précédent est conservé.
- Le Pathfinder général stocke jusqu'à 8 interdictions directionnelles temporaires X/Y/Z pendant 2000 ms, uniquement en cas de mouvement rejeté de la requête active correspondante. La rotation, la séquence inconnue, la resynchronisation et la demande ancienne/étrangère ne créent pas une telle interdiction. Une nouvelle requête externe et la perte du contexte de la carte/du lecteur les effacent. La recherche de géométrie chargée tente de contourner la transition ; il ne s'agit pas de connaître tous les obstacles du serveur. Sans changer les X/Y/Z du lecteur, jusqu'à 8 recalculs internes sont autorisés avec une pause d'au moins 40 ms. Il n'y a pas de parcours complet ou ce budget est épuisé - le parcours se termine. La tâche de coordination se termine ensuite après avoir traité les étapes soumises ; mobile-Follow peut réessayer en raison de son retard.
Chaque exemple peut être enregistré dans un fichier séparé .csx et exécuté dans IDE. Les fonctions d'objet UO et d'attente fournissent l'hôte de la session de jeu en cours. Remplacez les noms, coordonnées et adresses de la démo serial par les vôtres.
Exécutez ce code dans un fichier .csx séparé. Les arguments sont visibles dans l’appel ; remplacez les noms, serials et adresses d’exemple par les vôtres.
Le résultat d’un seul appel est affiché dans le journal. Un nombre n’est pas converti en bool ; un tableau est affiché par son nombre d’éléments.
var result = UO.MoveXYZ(UO.GetX() + 1, UO.GetY(), UO.GetZ(), 0, 0, false);
UO.Print("MoveXYZ: " + Convert.ToString(result));Paramètres et déroulement de l’exécution :
- x/y/z est le point cible. accuracyXY=0 et accuracyZ=0 nécessitent une position précise.
- running=false - marcher. Si la surface adjacente a une hauteur différente, le résultat peut être 0.
var ok = UO.MoveXYZ(UO.GetX() + 1, UO.GetY(), UO.GetZ(), 0, 0, false);
UO.Print(Convert.ToString(ok));Paramètres et déroulement de l’exécution :
- Préparation : le personnage doit être dans le jeu, et le point doit exister sur la carte actuelle. 1279/540/20 sont des coordonnées d'entraînement : remplacez-les par votre point disponible, incluant la hauteur réelle de la surface.
-
- destinationX=1279 est le premier argument, la coordonnée mondiale X de la cible.
-
- destinationY=540 est le deuxième argument, la coordonnée mondiale Y de la cible.
-
- destinationZ=20 — troisième argument, hauteur. L'équipe doit trouver un passage ou un escalier ; la valeur 20 en elle-même n'est pas transférée au sol.
-
- accuracyXY=1 vous permet de terminer dans une cellule le long de chaque coordonnée horizontale. La cellule adjacente en diagonale convient également.
-
- accuracyZ=2 autorise des hauteurs de 18 à 22 inclus. Un match X/Y sur un autre étage ne suffit pas pour réussir.
-
- running=true requêtes en cours d'exécution. Pour marcher, remplacez true par false.
-
- timeout=8000 limite l'attente après le début de l'itinéraire à huit secondes. Passé ce temps, alors que le mouvement est encore en cours, la commande l'arrête et renvoie 0.
-
- maxSteps=100 limite le nombre de changements de position observés. Ce n'est pas le nombre exact de carrés parcourus ; plusieurs étapes peuvent se produire entre les sondages.
-
- avoidMobiles=true interdit de passer par les caractères pris en compte lors du calcul de l'itinéraire.
-
- openDoors=true autorise les tentatives d'ouverture de portes en cours de route. Cet indicateur ne contourne pas une porte verrouillée ou les restrictions du serveur.
- atteint reçoit int 1 ou 0 après la fin de l'appel. si atteint == 1 exécute la branche réussie ; sinon, il gère l'échec de l'atteinte de l'objectif sans répéter sans cesse la commande.
- La dernière ligne imprime le X/Y/Z actuel pour vérification. Si la procédure est abandonnée, aucune autre ligne, y compris cette sortie, n'est exécutée.
return RunScenario();
object? RunScenario()
{
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;Paramètres et déroulement de l’exécution :
- x/y/z=1445/1690/0; accuracyXY=1, accuracyZ=3; running=true.
- timeout=5000, maxSteps=60 des mouvements observés, avoidMobiles=true et openDoors=false.
return new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
private readonly Func<int, Task> WaitAsync;
private readonly string[] Args;
private readonly CancellationToken Cancellation;
private readonly Action Checkpoint;
public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
{
UO = api;
WaitAsync = wait;
Args = args;
Cancellation = cancellation;
Checkpoint = checkpoint;
}
public object? RunScenario()
{
var ok = UO.MoveXYZ(1445, 1690, 0, 1, 3, true, 5000, 60, true, false);
UO.Print("Result: " + Convert.ToString(ok));
return null;
}
}Paramètres et déroulement de l’exécution :
- Les lignes avec # sont des commentaires C# : elles sont enregistrées lors de la copie et ne sont pas exécutées. L'exemple contient les deux parties nécessaires : la fonction GoToPoint et la procédure exécutable Main.
- Les six paramètres GoToPoint sont transmis à MoveXYZ sans modification. Quatre paramètres supplémentaires sont spécifiés dans la fonction : 8000 ms, 100 changements de position observés, traversée de caractères et ouverture de porte.
- À cet effet, 1279/540/20 avec des tolérances 1/2 X=1278..1280, Y=539..541, Z=18..22 conviennent. Un point situé à une autre altitude au-delà de 18..22 n'est pas considéré comme atteint.
- Il s'agit d'un wrapper autour de la commande réelle, et non d'une seconde implémentation de la recherche de chemin dans le script. Il n'appelle pas de GetPathArray supplémentaire et ne déclenche pas de tentatives infinies. Si cela n'est pas réalisé, la procédure appelante reçoit 0 et choisit une action supplémentaire.
Intervalle minimum de pas : marche - marche 400 ms, course 200 ms ; équitation - marche 200 ms, course 100 ms.
Il s'agit de limites client standard et non de paramètres automatiquement définis pour votre partition. La vitesse du serveur et les modes de vol sont comptés séparément. Les minuteries de script peuvent ralentir le mouvement, mais ne réduisent pas ces limites.
Les étapes, les itinéraires, Follow, les commandes souris/touches et la carte utilisent la file d'attente partagée du personnage. Le remplacement de l'itinéraire, le virage ou l'ajustement de la position par le serveur n'annule pas la pause restante après la demande d'étape. Après le délai, il n'y a pas de rafale rapide pour compenser les images perdues. L’attente de confirmation, les obstacles et une mauvaise communication peuvent ralentir le mouvement.
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;C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Paramètres: x (Any), y (Any), z (Any), accuracyXY (Any), accuracyZ (Any), running (Any)
Résultat: int / Integer.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.Register [MoveXYZ]. -
InjectionScript.Runtime.InjectionApiUO.CompactMoveXYZ:CompactMoveXYZ(values).
L’appel exécute le delegate du gestionnaire enregistré. La méthode d’enregistrement crée ce delegate lors de la construction de l’API.
Code interne de l’implémentation ; ce n’est pas un script autonome.
values => new InjectionValue(CompactMoveXYZ(values))
UO.MoveXYZ(x, y, z, accuracyXY, accuracyZ, running, timeout) — UO.MoveXYZ(Any,Any,Any,Any,Any,Any,Any)
Paramètres: x (Any), y (Any), z (Any), accuracyXY (Any), accuracyZ (Any), running (Any), timeout (Any)
Résultat: int / Integer.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.Register [MoveXYZ]. -
InjectionScript.Runtime.InjectionApiUO.CompactMoveXYZ:CompactMoveXYZ(values).
L’appel exécute le delegate du gestionnaire enregistré. La méthode d’enregistrement crée ce delegate lors de la construction de l’API.
Code interne de l’implémentation ; ce n’est pas un script autonome.
values => new InjectionValue(CompactMoveXYZ(values))
UO.MoveXYZ(x, y, z, accuracyXY, accuracyZ, running, timeout, maxSteps) — UO.MoveXYZ(Any,Any,Any,Any,Any,Any,Any,Any)
Paramètres: x (Any), y (Any), z (Any), accuracyXY (Any), accuracyZ (Any), running (Any), timeout (Any), maxSteps (Any)
Résultat: int / Integer.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.Register [MoveXYZ]. -
InjectionScript.Runtime.InjectionApiUO.CompactMoveXYZ:CompactMoveXYZ(values).
L’appel exécute le delegate du gestionnaire enregistré. La méthode d’enregistrement crée ce delegate lors de la construction de l’API.
Code interne de l’implémentation ; ce n’est pas un script autonome.
values => new InjectionValue(CompactMoveXYZ(values))
UO.MoveXYZ(x, y, z, accuracyXY, accuracyZ, running, timeout, maxSteps, avoidMobiles) — UO.MoveXYZ(Any,Any,Any,Any,Any,Any,Any,Any,Any)
Paramètres: x (Any), y (Any), z (Any), accuracyXY (Any), accuracyZ (Any), running (Any), timeout (Any), maxSteps (Any), avoidMobiles (Any)
Résultat: int / Integer.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.Register [MoveXYZ]. -
InjectionScript.Runtime.InjectionApiUO.CompactMoveXYZ:CompactMoveXYZ(values).
L’appel exécute le delegate du gestionnaire enregistré. La méthode d’enregistrement crée ce delegate lors de la construction de l’API.
Code interne de l’implémentation ; ce n’est pas un script autonome.
values => new InjectionValue(CompactMoveXYZ(values))
UO.MoveXYZ(x, y, z, accuracyXY, accuracyZ, running, timeout, maxSteps, avoidMobiles, openDoors) — UO.MoveXYZ(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)
Paramètres: x (Any), y (Any), z (Any), accuracyXY (Any), accuracyZ (Any), running (Any), timeout (Any), maxSteps (Any), avoidMobiles (Any), openDoors (Any)
Résultat: int / Integer.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.Register [MoveXYZ]. -
InjectionScript.Runtime.InjectionApiUO.CompactMoveXYZ:CompactMoveXYZ(values).
L’appel exécute le delegate du gestionnaire enregistré. La méthode d’enregistrement crée ce delegate lors de la construction de l’API.
Code interne de l’implémentation ; ce n’est pas un script autonome.
values => new InjectionValue(CompactMoveXYZ(values))Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
void UO.MoverStop();Arrête l'itinéraire automatique de Pathfinder.
Il n'y a pas de paramètres.
void - aucune valeur de retour. Appelez sur une ligne séparée ; ce n'est pas true/false ou le nombre d'étapes.
- Supprime le mouvement automatique local. Les étapes déjà envoyées et les confirmations du serveur ne sont pas rappelées.
- Ce n'est pas TerminateAll : l'exécution des lignes de script restantes et des autres procédures continue.
Chaque exemple peut être enregistré dans un fichier séparé .csx et exécuté dans IDE. Les fonctions d'objet UO et d'attente fournissent l'hôte de la session de jeu en cours. Remplacez les noms, coordonnées et adresses de la démo serial par les vôtres.
Exécutez ce code dans un fichier .csx séparé. Les arguments sont visibles dans l’appel ; remplacez les noms, serials et adresses d’exemple par les vôtres.
La commande forme une instruction séparée. Le message précédent indique le début de l’appel et ne confirme aucune action du serveur.
UO.Print("Calling UO.MoverStop");
UO.MoverStop();Paramètres et déroulement de l’exécution :
- Il n'y a pas d'arguments.
- La commande ne renvoie pas de code de réussite.
UO.MoverStop();Paramètres et déroulement de l’exécution :
- Move() lit le mouvement automatique.
- Print — message de script local ; ce n'est pas une confirmation du serveur.
return RunScenario();
object? RunScenario()
{
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;Paramètres et déroulement de l’exécution :
- UO.Wait=100 ms permet au client de traiter les prochains événements.
- Après l'arrêt, les coordonnées sont lues séparément ; le délai ne garantit pas la réception de tous les accusés de réception du réseau.
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)));
}C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Paramètres: Aucun paramètre.
Résultat: void / Unit.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.StopMoving:bridge.StopMoving().
Code interne de l’implémentation ; ce n’est pas un script autonome.
case "moverstop": bridge.StopMoving(); return InjectionValue.Unit;Українська · Русский · English · Deutsch · Français · Italiano · Español · 繁體中文 · 日本語 · 한국어
int UO.Moving();Vérifie le mouvement de votre personnage.
Il n'y a pas de paramètres.
int bool (1/0) : 1 - Pathfinder automatique est actif ou il y a encore des étapes dans la file d'attente du personnage ; 0 - les deux sont manquants ou le personnage n'est pas chargé. Ce n'est pas une confirmation de l'atteinte d'un objectif ou du nombre d'étapes.
Le résultat de la commande est un indicateur numérique : 1 signifie une condition remplie, 0 signifie une condition non remplie. Après var result = command(...) vérifiez si (result != 0) ou if (result == 0). Enregistrez le résultat d'un appel : un appel répété peut effectuer à nouveau l'action ou lire l'état qui a déjà changé.
- Les données locales déjà reçues sont lues. La requête n'ouvre pas le statut et n'oblige pas le serveur à envoyer une mise à jour. Après un décès, une transition de map ou une suppression d'objet, les valeurs peuvent changer entre deux appels.
- C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Chaque exemple peut être enregistré dans un fichier séparé .csx et exécuté dans IDE. Les fonctions d'objet UO et d'attente fournissent l'hôte de la session de jeu en cours. Remplacez les noms, coordonnées et adresses de la démo serial par les vôtres.
Exécutez ce code dans un fichier .csx séparé. Les arguments sont visibles dans l’appel ; remplacez les noms, serials et adresses d’exemple par les vôtres.
Le résultat d’un seul appel est affiché dans le journal. Un nombre n’est pas converti en bool ; un tableau est affiché par son nombre d’éléments.
var result = UO.Moving();
UO.Print("Moving: " + Convert.ToString(result));Paramètres et déroulement de l’exécution :
- Les parenthèses vides indiquent self. actif — numéro 1 ou 0 ; Le texte du message sert d'exemple de traitement de branchement.
- 1 - Pathfinder automatique est actif ou il y a encore des étapes dans la file d'attente du personnage ; 0 - les deux sont manquants ou le personnage n'est pas chargé. Ce n'est pas une confirmation de l'atteinte d'un objectif ou du nombre d'étapes.
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;Paramètres et déroulement de l’exécution :
- La commande n'a pas d'argument objet : même après Exists(self), elle ne lit que son propre état.
- Exists(self) vérifie la charge du joueur séparément du drapeau demandé. Le monde peut changer entre les contrôles.
return RunScenario();
object? RunScenario()
{
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;Paramètres et déroulement de l’exécution :
- Les deux appels sans arguments se lisent self ; UO.Wait(500) - faites une pause d'une demi-seconde.
- Deux instantanés de drapeau sont comparés. Les transitions entre les prises de vue peuvent être ignorées ; ce n'est pas un abonnement à tous les événements du serveur.
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;
}C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.
Paramètres: Aucun paramètre.
Résultat: int / Integer.
Pendant un appel:
-
InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [Moving]. -
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.IsMoving:bridge.IsMoving().
L’appel exécute le delegate du gestionnaire enregistré. La méthode d’enregistrement crée ce delegate lors de la construction de l’API.
Code interne de l’implémentation ; ce n’est pas un script autonome.
() => bridge.IsMoving()Création de l’API: Ces fonctions enregistrent l’API. Elles ne sont pas exécutées à nouveau pour chaque appel de commande.
ClassicUO — Bad Newbie & C# Scripts IDE