Skip to content

FR UO Topic movement Part 2

Jump to bottom
Codex edited this page Oct 18, 2026 · 5 revisions

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

Mouvement — 2

Accueil · C# · IDE · UO API · A–Z · Exemples · Langues

Parties de la référence

1 · 2

Référence complète des commandes

UO.NewMoveXY

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

Signatures C#

int UO.NewMoveXY(object? xdst, object? ydst, object? optimized, object? accuracy, object? running);
int UO.NewMoveXY(object? xdst, object? ydst, object? optimized, object? accuracy, object? running, object? stepCallback);
int UO.NewMoveXY(object? xdst, object? ydst, object? optimized, object? accuracy, object? running, object? stepCallback, object? timeout);
int UO.NewMoveXY(object? xdst, object? ydst, object? optimized, object? accuracy, object? running, object? stepCallback, object? timeout, object? maxSteps);
int UO.NewMoveXY(object? xdst, object? ydst, object? optimized, object? accuracy, object? running, object? stepCallback, object? timeout, object? maxSteps, object? maxDistance);
int UO.NewMoveXY(object? xdst, object? ydst, object? optimized, object? accuracy, object? running, object? stepCallback, object? timeout, object? maxSteps, object? maxDistance, object? accuracyZ);
int UO.NewMoveXY(object? xdst, object? ydst, object? optimized, object? accuracy, object? running, object? stepCallback, object? timeout, object? maxSteps, object? maxDistance, object? accuracyZ, object? avoidMobiles);
int UO.NewMoveXY(object? xdst, object? ydst, object? optimized, object? accuracy, object? running, object? stepCallback, object? timeout, object? maxSteps, object? maxDistance, object? accuracyZ, object? avoidMobiles, object? openDoors);
int UO.NewMoveXY(object? xdst, object? ydst, object? optimized, object? accuracy, object? running, object? stepCallback, object? timeout, object? maxSteps, object? maxDistance, object? accuracyZ, object? avoidMobiles, object? openDoors, object? stopOnStuck);

Déplace le personnage vers X/Y, attend la fin et vérifie l'atteinte de l'objectif ; prend en charge des restrictions et des rappels supplémentaires.

Paramètres

  • 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.
  • timeout — Limite d'attente facultative en millisecondes ; un argument manquant, 0 et une valeur négative indiquent l'absence de cette limite supplémentaire.
  • 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.
  • 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é.
  • 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 essentiellement la limite Z. Pour NewMoveXY, le Z cible est égal au Z du personnage lorsqu'il est invoqué ; la tolérance par défaut est 255.
  • 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.
  • stopOnStuck - true termine le mouvement avec 0, si après planification environ 1000 ms X/Y/Z n'ont pas changé. Les parties actives de recherche et de recalcul réinitialisent ce temporisateur ; le délai d'attente séparé continue de fonctionner. La valeur par défaut est false.

Valeur de retour

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

Comportement

  • 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.
  • UO.LimitMove limite la distance à la destination : 2000 par défaut, zéro sans limite. Les limites cachées de 4096 pas/nœuds et 10000 nœuds sont supprimées. Le travail se déroule par tranches interruptibles. GetPathArray respecte le seuil d’endurance moveThroughNPC et moveOpenDoor.
  • 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.

Le rappel d'étape dans C# est explicitement enregistré via RegisterStepCallback(name, Func<int,int,int,bool>) ou Func<int,int,int,int>. Les coordonnées x/y/z sont transmises sous la forme int ; false/0 arrête l'itinéraire, true/nombre non nul continue. L'enregistrement est valable dans l'exécution en cours et est libéré avec celle-ci.

Scripts C# autonomes

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.

Exemple simple

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.NewMoveXY((UO.GetX() + 3), UO.GetY(), true, 0, false);
UO.Print("NewMoveXY: " + Convert.ToString(result));

1. Atteignez le point suivant et vérifiez le résultat - script direct

Paramètres et déroulement de l’exécution :

  • x/y — objectif mondial ; Optimized=true, Accuracy=0 nécessite un X/Y précis, Running=false spécifie la marche.
  • ok - int 1 ou 0, pas le nombre de cellules passées. La cible doit être disponible sur la carte actuelle.
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;

2. Courir avec une limite de temps et de distance - Fonction de script

Paramètres et déroulement de l’exécution :

  • 1445/1690 - exemple d'objectif ; Accuracy=1 permet de se garer à proximité. En cours d'exécution=true. StepCallback=0 désactive le rappel.
  • délai d'attente=5000 ms ; maxSteps=100 mouvements observés ; maxDistance=30 est vérifié depuis l'origine.
  • AccuracyZ=255 ne nécessite pas de sol ; avoidMobiles=true, openDoors=true, stopOnStuck=true incluent ces conditions.
return  RunScenario();
 object? RunScenario()
{
    var ok = UO.NewMoveXY(1445, 1690, true, 1, true, 0, 5000, 100, 30, 255, true, true, true);
    UO.Print("Move result: " + Convert.ToString(ok));
    return null;
}

3. Test d'endurance en rappel - classe de script

Paramètres et déroulement de l’exécution :

  • StepCallback="AfterStep" reçoit trois coordonnées. L'inscription RegisterStepCallback associe le nom au délégué bool. Lorsque Stamina <= 10 il renvoie false et s'arrête de bouger ; true continue le parcours.
  • timeout=5000 ms limite l'attente. Le rappel est appelé après qu'un changement est remarqué et n'est pas garanti pour chaque étape du réseau ; Ne faites pas une longue attente ou un nouvel itinéraire.
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 stepRegistration = RegisterStepCallback("AfterStep", AfterStep);
        var ok = UO.NewMoveXY(UO.GetX() + 5, UO.GetY(), true, 0, false, "AfterStep", 5000);
        UO.Print("Move result: " + Convert.ToString(ok));
        return null;
    }

    bool AfterStep(int x, int y, int z)
    {
        UO.Print("Position: " + Convert.ToString(x) + "," + Convert.ToString(y) + "," + Convert.ToString(z));
        return UO.Stamina() > 10;
    }

    private IDisposable RegisterStepCallback(string name, Func<int, int, int, bool> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterStepCallback(name, handler);
    private IDisposable RegisterStepCallback(string name, Func<int, int, int, int> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterStepCallback(name, handler);
}

4. GoToPoint : code de fonction d'assistance complet et Main - script direct

Paramètres et déroulement de l’exécution :

  • GoToPoint est une fonction d'assistance pour cet exemple uniquement. Ses quatre paramètres x/y/précision/exécution sont décrits au-dessus de la déclaration de la fonction ; le corps complet de la fonction se trouve dans le même bloc copié.
  • Main évalue la cible et appelle GoToPoint. Il ajoute optimisé=true, callback=0, timeout=8000 et maxSteps=100, appelle NewMoveXY une fois et renvoie le int renvoyé à Main.
  • NewMoveXY est une commande client intégrée. Sa recherche A*, son contrôle de perméabilité et le traitement des étapes du serveur sont implémentés dans le client, et non dans des procédures cachées supplémentaires de ce script.
  • Dans cet exemple, le rappel est désactivé. Si un autre exemple spécifie un nom de rappel ou appelle une fonction de script supplémentaire, sa définition doit également être donnée dans son intégralité.
  • Dans C# vérifiez si (atteint != 0); un résultat numérique de 0 indique un échec. Une comparaison directe de int avec bool n'est pas acceptable. Une annulation d'urgence interrompt l'exécution et n'est pas nécessaire pour renvoyer false.
var x = UO.GetX() + 3;
var y = UO.GetY();
var reached = GoToPoint(x, y, 0, true);
if (Truth(Truth(reached) == true))
{
    UO.Print("Destination reached");
}
else
{
    UO.Print("Destination not reached");
}

dynamic GoToPoint(dynamic x, dynamic y, dynamic accuracy, dynamic running)
{
    dynamic optimized = true;
    var callback = 0;
    var timeout = 8000;
    var maxSteps = 100;
    var reached = UO.NewMoveXY(x, y, optimized, accuracy, running, callback, timeout, maxSteps);
    return reached;
}

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

Implémentation de la commande

C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.

UO.NewMoveXY(xdst, ydst, optimized, accuracy, running) — UO.NewMoveXY(Any,Any,Any,Any,Any)

Paramètres: xdst (Any), ydst (Any), optimized (Any), accuracy (Any), running (Any)

Résultat: int / Integer.

Pendant un appel:

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(CompactNewMoveXY(values))

UO.NewMoveXY(xdst, ydst, optimized, accuracy, running, stepCallback) — UO.NewMoveXY(Any,Any,Any,Any,Any,Any)

Paramètres: xdst (Any), ydst (Any), optimized (Any), accuracy (Any), running (Any), stepCallback (Any)

Résultat: int / Integer.

Pendant un appel:

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(CompactNewMoveXY(values))

UO.NewMoveXY(xdst, ydst, optimized, accuracy, running, stepCallback, timeout) — UO.NewMoveXY(Any,Any,Any,Any,Any,Any,Any)

Paramètres: xdst (Any), ydst (Any), optimized (Any), accuracy (Any), running (Any), stepCallback (Any), timeout (Any)

Résultat: int / Integer.

Pendant un appel:

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(CompactNewMoveXY(values))

UO.NewMoveXY(xdst, ydst, optimized, accuracy, running, stepCallback, timeout, maxSteps) — UO.NewMoveXY(Any,Any,Any,Any,Any,Any,Any,Any)

Paramètres: xdst (Any), ydst (Any), optimized (Any), accuracy (Any), running (Any), stepCallback (Any), timeout (Any), maxSteps (Any)

Résultat: int / Integer.

Pendant un appel:

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(CompactNewMoveXY(values))

UO.NewMoveXY(xdst, ydst, optimized, accuracy, running, stepCallback, timeout, maxSteps, maxDistance) — UO.NewMoveXY(Any,Any,Any,Any,Any,Any,Any,Any,Any)

Paramètres: xdst (Any), ydst (Any), optimized (Any), accuracy (Any), running (Any), stepCallback (Any), timeout (Any), maxSteps (Any), maxDistance (Any)

Résultat: int / Integer.

Pendant un appel:

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(CompactNewMoveXY(values))

UO.NewMoveXY(xdst, ydst, optimized, accuracy, running, stepCallback, timeout, maxSteps, maxDistance, accuracyZ) — UO.NewMoveXY(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)

Paramètres: xdst (Any), ydst (Any), optimized (Any), accuracy (Any), running (Any), stepCallback (Any), timeout (Any), maxSteps (Any), maxDistance (Any), accuracyZ (Any)

Résultat: int / Integer.

Pendant un appel:

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(CompactNewMoveXY(values))

UO.NewMoveXY(xdst, ydst, optimized, accuracy, running, stepCallback, timeout, maxSteps, maxDistance, accuracyZ, avoidMobiles) — UO.NewMoveXY(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)

Paramètres: xdst (Any), ydst (Any), optimized (Any), accuracy (Any), running (Any), stepCallback (Any), timeout (Any), maxSteps (Any), maxDistance (Any), accuracyZ (Any), avoidMobiles (Any)

Résultat: int / Integer.

Pendant un appel:

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(CompactNewMoveXY(values))

UO.NewMoveXY(xdst, ydst, optimized, accuracy, running, stepCallback, timeout, maxSteps, maxDistance, accuracyZ, avoidMobiles, openDoors) — UO.NewMoveXY(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)

Paramètres: xdst (Any), ydst (Any), optimized (Any), accuracy (Any), running (Any), stepCallback (Any), timeout (Any), maxSteps (Any), maxDistance (Any), accuracyZ (Any), avoidMobiles (Any), openDoors (Any)

Résultat: int / Integer.

Pendant un appel:

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(CompactNewMoveXY(values))

UO.NewMoveXY(xdst, ydst, optimized, accuracy, running, stepCallback, timeout, maxSteps, maxDistance, accuracyZ, avoidMobiles, openDoors, stopOnStuck) — UO.NewMoveXY(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)

Paramètres: xdst (Any), ydst (Any), optimized (Any), accuracy (Any), running (Any), stepCallback (Any), timeout (Any), maxSteps (Any), maxDistance (Any), accuracyZ (Any), avoidMobiles (Any), openDoors (Any), stopOnStuck (Any)

Résultat: int / Integer.

Pendant un appel:

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(CompactNewMoveXY(values))

UO.OpenDoor

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

Signatures C#

void UO.OpenDoor();

Demande que la porte soit ouverte pour le personnage.

Paramètres

Il n'y a pas de paramètres.

Valeur de retour

void - aucune valeur. Appelez sur une ligne séparée ; l'achèvement ne confirme pas l'action du serveur.

Comportement

  • OpenDoor appelle GameActions.OpenDoor via Invoke. La porte série n'est pas acceptée ; les règles de recherche et de découverte appartiennent à GameActions/server.
  • Dans les exemples, UO.Wait spécifie uniquement une pause de script ; la fin de la pause ne prouve pas que le serveur a complété la requête.

Scripts C# autonomes

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.

Exemple simple

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

1. Appel direct - script direct

Paramètres et déroulement de l’exécution :

  • Demande que la porte soit ouverte pour le personnage.
UO.OpenDoor();

2. Option explicite - fonction de script

Paramètres et déroulement de l’exécution :

  • OpenDoor appelle GameActions.OpenDoor via Invoke. La porte série n'est pas acceptée ; les règles de recherche et de découverte appartiennent à GameActions/server.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.IsOnline()))
    {
        UO.OpenDoor();
    }

    return null;
}

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

3. Fonction d'assistance complète - Classe de script

Paramètres et déroulement de l’exécution :

  • Dans les exemples, UO.Wait spécifie uniquement une pause de script ; la fin de la pause ne prouve pas que le serveur a complété la requête.
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.OpenDoor();
        UO.Wait(250);
        UO.Print("Door request sent");
        return null;
    }
}

Implémentation de la commande

C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.

UO.OpenDoor() — UO.OpenDoor()

Paramètres: Aucun paramètre.

Résultat: void / Unit.

Pendant un appel:

Code interne de l’implémentation ; ce n’est pas un script autonome.

case "opendoor": bridge.OpenDoor(); break;

UO.PMove

PMove attend la recherche du chemin et la fin du déplacement. XY exige les coordonnées exactes ; XYZ exige aussi la hauteur indiquée. Retour void : comparez les coordonnées réelles. NewMoveXY ou MoveXYZ renvoient un résultat numérique. Aucun délai implicite de 30 secondes.

UO.PMove

UO.PredictedDirection

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

Signatures C#

int UO.PredictedDirection();

Lit le côté de la direction prédite après les pas déjà mis en file d'attente du personnage.

Paramètres

Il n'y a pas de paramètres.

Valeur de retour

int direction 0..7, sans bit d'exécution. 0 - nord ou absence de caractère.

Comportement

  • Seule la fonction affichée dans la syntaxe est UO sans arguments. Il n'y a pas de paramètres de cible, serial, type, de cible, de distance ou de délai d'attente. Le nombre non bool, ID ou la notation de tuile : 1 ne signifie pas atteindre l'objectif.
  • GetEndPosition lit la direction X/Y/Z/du dernier Mobile.Step déjà ajouté. Lorsque la file d'attente est vide, lit la position/direction actuelle du personnage. Il s'agit d'une lecture O(1) : l'étape n'est pas récupérée, le mouvement et le paquet ne sont pas envoyés, la route n'est pas calculée, la commande n'attend pas de réalisation.
  • Directions du monde : 0 nord, 1 nord-est, 2 est, 3 sud-est, 4 sud, 5 sud-ouest, 6 ouest, 7 nord-ouest. L'écran est isométrique. Direction.Mask supprime l'indicateur en cours d'exécution ; la vitesse ne revient pas.
  • Il s'agit d'une prévision locale, pas d'une arrivée confirmée. Des étapes nouvelles/terminées, une panne de serveur, la suppression de la file d'attente ou la téléportation peuvent le modifier. Les appels de composants individuels ne sont pas atomiques ; une correspondance X ne prouve pas une correspondance Y/Z ou une confirmation du serveur.
  • Invoke effectue une lecture sur le thread du jeu ; Le thread de travail attend que le gestionnaire traite la demande. L'annulation du script interrompt l'attente. Les pauses et les demandes réseau supplémentaires ne sont pas ajoutées.
  • Les implémentations externes d'IApiBridge sans IPredictedMovementBridge conservent une lecture de secours des coordonnées/direction actuelles. Le classique UO implémente une interface sensible aux files d'attente.

Scripts C# autonomes

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.

Exemple simple

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

1. Lire un composant - script direct

Paramètres et déroulement de l’exécution :

  • prédit enregistre un appel sans arguments ; Convert.ToString formate le numéro du journal.
var predicted = UO.PredictedDirection();
UO.Print("Predicted: " + Convert.ToString(predicted));

2. Observer le changement des prévisions - fonction de script

Paramètres et déroulement de l’exécution :

  • UO.Wait(100) met l'exemple en pause pendant 100 ms. avant et après peuvent coïncider même avec un mouvement intermédiaire ; ces lectures ne déclenchent pas de mouvement.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.PredictedDirection();
    await Delay(100);
    var after = UO.PredictedDirection();
    if (Truth(before != after))
    {
        UO.Print("Prediction changed: " + Convert.ToString(before) + " -> " + Convert.ToString(after));
    }

    return null;
}

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

3. Fonction de comparaison complète - Classe de script

Paramètres et déroulement de l’exécution :

  • attendu - un exemple de coordonnées/hauteur/direction, pas un argument de la commande native. PredictionEquals vérifie UO.Self(), lit la valeur une fois et renvoie 1 (condition remplie) si elle est égale, sinon 0 (condition non remplie). L’intégralité du code de fonction est affiché sous Principal. La coïncidence d'un composant ne signifie pas l'arrivé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(Truth(PredictionEquals(4)) == true))
        {
            UO.Print("Queued endpoint matches this component");
        }
        else
        {
            UO.Print("Different component or no player");
        }

        return null;
    }

    dynamic PredictionEquals(dynamic expected)
    {
        if (Truth(UO.Self() == 0))
        {
            return false;
        }

        var predicted = UO.PredictedDirection();
        return Truth(predicted == expected);
    }

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

Implémentation de la commande

C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.

UO.PredictedDirection() — UO.PredictedDirection()

Paramètres: Aucun paramètre.

Résultat: int / Integer.

Pendant un appel:

Code interne de l’implémentation ; ce n’est pas un script autonome.

case "predicteddirection": return new InjectionValue(ReadPredictedCoordinate(3));

UO.PredictedX

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

Signatures C#

int UO.PredictedX();

Lit la coordonnée X prédite après les pas déjà mis en file d'attente du personnage.

Paramètres

Il n'y a pas de paramètres.

Valeur de retour

int X dans les cellules de la carte. 0 - coordonnée valide ou absence de caractère.

Comportement

  • Seule la fonction affichée dans la syntaxe est UO sans arguments. Il n'y a pas de paramètres de cible, serial, type, de cible, de distance ou de délai d'attente. Le nombre non bool, ID ou la notation de tuile : 1 ne signifie pas atteindre l'objectif.
  • GetEndPosition lit la direction X/Y/Z/du dernier Mobile.Step déjà ajouté. Lorsque la file d'attente est vide, lit la position/direction actuelle du personnage. Il s'agit d'une lecture O(1) : l'étape n'est pas récupérée, le mouvement et le paquet ne sont pas envoyés, la route n'est pas calculée, la commande n'attend pas de réalisation.
  • X et Y sont des coordonnées du monde/carte, pas des pixels de conteneur. Z est la hauteur, pas le numéro d'étage. Un seul composant est renvoyé, pas un tableau ni la destination finale de l'ensemble de l'itinéraire.
  • Il s'agit d'une prévision locale, pas d'une arrivée confirmée. Des étapes nouvelles/terminées, une panne de serveur, la suppression de la file d'attente ou la téléportation peuvent le modifier. Les appels de composants individuels ne sont pas atomiques ; une correspondance X ne prouve pas une correspondance Y/Z ou une confirmation du serveur.
  • Invoke effectue une lecture sur le thread du jeu ; Le thread de travail attend que le gestionnaire traite la demande. L'annulation du script interrompt l'attente. Les pauses et les demandes réseau supplémentaires ne sont pas ajoutées.
  • Les implémentations externes d'IApiBridge sans IPredictedMovementBridge conservent une lecture de secours des coordonnées/direction actuelles. Le classique UO implémente une interface sensible aux files d'attente.

Scripts C# autonomes

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.

Exemple simple

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

1. Lire un composant - script direct

Paramètres et déroulement de l’exécution :

  • prédit enregistre un appel sans arguments ; Convert.ToString formate le numéro du journal.
var predicted = UO.PredictedX();
UO.Print("Predicted: " + Convert.ToString(predicted));

2. Observer le changement des prévisions - fonction de script

Paramètres et déroulement de l’exécution :

  • UO.Wait(100) met l'exemple en pause pendant 100 ms. avant et après peuvent coïncider même avec un mouvement intermédiaire ; ces lectures ne déclenchent pas de mouvement.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.PredictedX();
    await Delay(100);
    var after = UO.PredictedX();
    if (Truth(before != after))
    {
        UO.Print("Prediction changed: " + Convert.ToString(before) + " -> " + Convert.ToString(after));
    }

    return null;
}

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

3. Fonction de comparaison complète - Classe de script

Paramètres et déroulement de l’exécution :

  • attendu - un exemple de coordonnées/hauteur/direction, pas un argument de la commande native. PredictionEquals vérifie UO.Self(), lit la valeur une fois et renvoie 1 (condition remplie) si elle est égale, sinon 0 (condition non remplie). L’intégralité du code de fonction est affiché sous Principal. La coïncidence d'un composant ne signifie pas l'arrivé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(Truth(PredictionEquals(1445)) == true))
        {
            UO.Print("Queued endpoint matches this component");
        }
        else
        {
            UO.Print("Different component or no player");
        }

        return null;
    }

    dynamic PredictionEquals(dynamic expected)
    {
        if (Truth(UO.Self() == 0))
        {
            return false;
        }

        var predicted = UO.PredictedX();
        return Truth(predicted == expected);
    }

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

Implémentation de la commande

C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.

UO.PredictedX() — UO.PredictedX()

Paramètres: Aucun paramètre.

Résultat: int / Integer.

Pendant un appel:

Code interne de l’implémentation ; ce n’est pas un script autonome.

case "predictedx": return new InjectionValue(ReadPredictedCoordinate(0));

UO.PredictedY

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

Signatures C#

int UO.PredictedY();

Lit la coordonnée Y prédite après les pas déjà mis en file d'attente du personnage.

Paramètres

Il n'y a pas de paramètres.

Valeur de retour

int Y dans les cellules de la carte. 0 - coordonnée valide ou absence de caractère.

Comportement

  • Seule la fonction affichée dans la syntaxe est UO sans arguments. Il n'y a pas de paramètres de cible, serial, type, de cible, de distance ou de délai d'attente. Le nombre non bool, ID ou la notation de tuile : 1 ne signifie pas atteindre l'objectif.
  • GetEndPosition lit la direction X/Y/Z/du dernier Mobile.Step déjà ajouté. Lorsque la file d'attente est vide, lit la position/direction actuelle du personnage. Il s'agit d'une lecture O(1) : l'étape n'est pas récupérée, le mouvement et le paquet ne sont pas envoyés, la route n'est pas calculée, la commande n'attend pas de réalisation.
  • X et Y sont des coordonnées du monde/carte, pas des pixels de conteneur. Z est la hauteur, pas le numéro d'étage. Un seul composant est renvoyé, pas un tableau ni la destination finale de l'ensemble de l'itinéraire.
  • Il s'agit d'une prévision locale, pas d'une arrivée confirmée. Des étapes nouvelles/terminées, une panne de serveur, la suppression de la file d'attente ou la téléportation peuvent le modifier. Les appels de composants individuels ne sont pas atomiques ; une correspondance X ne prouve pas une correspondance Y/Z ou une confirmation du serveur.
  • Invoke effectue une lecture sur le thread du jeu ; Le thread de travail attend que le gestionnaire traite la demande. L'annulation du script interrompt l'attente. Les pauses et les demandes réseau supplémentaires ne sont pas ajoutées.
  • Les implémentations externes d'IApiBridge sans IPredictedMovementBridge conservent une lecture de secours des coordonnées/direction actuelles. Le classique UO implémente une interface sensible aux files d'attente.

Scripts C# autonomes

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.

Exemple simple

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

1. Lire un composant - script direct

Paramètres et déroulement de l’exécution :

  • prédit enregistre un appel sans arguments ; Convert.ToString formate le numéro du journal.
var predicted = UO.PredictedY();
UO.Print("Predicted: " + Convert.ToString(predicted));

2. Observer le changement des prévisions - fonction de script

Paramètres et déroulement de l’exécution :

  • UO.Wait(100) met l'exemple en pause pendant 100 ms. avant et après peuvent coïncider même avec un mouvement intermédiaire ; ces lectures ne déclenchent pas de mouvement.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.PredictedY();
    await Delay(100);
    var after = UO.PredictedY();
    if (Truth(before != after))
    {
        UO.Print("Prediction changed: " + Convert.ToString(before) + " -> " + Convert.ToString(after));
    }

    return null;
}

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

3. Fonction de comparaison complète - Classe de script

Paramètres et déroulement de l’exécution :

  • attendu - un exemple de coordonnées/hauteur/direction, pas un argument de la commande native. PredictionEquals vérifie UO.Self(), lit la valeur une fois et renvoie 1 (condition remplie) si elle est égale, sinon 0 (condition non remplie). L’intégralité du code de fonction est affiché sous Principal. La coïncidence d'un composant ne signifie pas l'arrivé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(Truth(PredictionEquals(1690)) == true))
        {
            UO.Print("Queued endpoint matches this component");
        }
        else
        {
            UO.Print("Different component or no player");
        }

        return null;
    }

    dynamic PredictionEquals(dynamic expected)
    {
        if (Truth(UO.Self() == 0))
        {
            return false;
        }

        var predicted = UO.PredictedY();
        return Truth(predicted == expected);
    }

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

Implémentation de la commande

C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.

UO.PredictedY() — UO.PredictedY()

Paramètres: Aucun paramètre.

Résultat: int / Integer.

Pendant un appel:

Code interne de l’implémentation ; ce n’est pas un script autonome.

case "predictedy": return new InjectionValue(ReadPredictedCoordinate(1));

UO.PredictedZ

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

Signatures C#

int UO.PredictedZ();

Lit la hauteur Z prévue après les pas déjà mis en file d'attente du personnage.

Paramètres

Il n'y a pas de paramètres.

Valeur de retour

int Z, hauteur signée -128..127; une valeur négative est retenue. 0 - hauteur acceptable ou absence du personnage.

Comportement

  • Seule la fonction affichée dans la syntaxe est UO sans arguments. Il n'y a pas de paramètres de cible, serial, type, de cible, de distance ou de délai d'attente. Le nombre non bool, ID ou la notation de tuile : 1 ne signifie pas atteindre l'objectif.
  • GetEndPosition lit la direction X/Y/Z/du dernier Mobile.Step déjà ajouté. Lorsque la file d'attente est vide, lit la position/direction actuelle du personnage. Il s'agit d'une lecture O(1) : l'étape n'est pas récupérée, le mouvement et le paquet ne sont pas envoyés, la route n'est pas calculée, la commande n'attend pas de réalisation.
  • X et Y sont des coordonnées du monde/carte, pas des pixels de conteneur. Z est la hauteur, pas le numéro d'étage. Un seul composant est renvoyé, pas un tableau ni la destination finale de l'ensemble de l'itinéraire.
  • Il s'agit d'une prévision locale, pas d'une arrivée confirmée. Des étapes nouvelles/terminées, une panne de serveur, la suppression de la file d'attente ou la téléportation peuvent le modifier. Les appels de composants individuels ne sont pas atomiques ; une correspondance X ne prouve pas une correspondance Y/Z ou une confirmation du serveur.
  • Invoke effectue une lecture sur le thread du jeu ; Le thread de travail attend que le gestionnaire traite la demande. L'annulation du script interrompt l'attente. Les pauses et les demandes réseau supplémentaires ne sont pas ajoutées.
  • Les implémentations externes d'IApiBridge sans IPredictedMovementBridge conservent une lecture de secours des coordonnées/direction actuelles. Le classique UO implémente une interface sensible aux files d'attente.

Scripts C# autonomes

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.

Exemple simple

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

1. Lire un composant - script direct

Paramètres et déroulement de l’exécution :

  • prédit enregistre un appel sans arguments ; Convert.ToString formate le numéro du journal.
var predicted = UO.PredictedZ();
UO.Print("Predicted: " + Convert.ToString(predicted));

2. Observer le changement des prévisions - fonction de script

Paramètres et déroulement de l’exécution :

  • UO.Wait(100) met l'exemple en pause pendant 100 ms. avant et après peuvent coïncider même avec un mouvement intermédiaire ; ces lectures ne déclenchent pas de mouvement.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.PredictedZ();
    await Delay(100);
    var after = UO.PredictedZ();
    if (Truth(before != after))
    {
        UO.Print("Prediction changed: " + Convert.ToString(before) + " -> " + Convert.ToString(after));
    }

    return null;
}

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

3. Fonction de comparaison complète - Classe de script

Paramètres et déroulement de l’exécution :

  • attendu - un exemple de coordonnées/hauteur/direction, pas un argument de la commande native. PredictionEquals vérifie UO.Self(), lit la valeur une fois et renvoie 1 (condition remplie) si elle est égale, sinon 0 (condition non remplie). L’intégralité du code de fonction est affiché sous Principal. La coïncidence d'un composant ne signifie pas l'arrivé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(Truth(PredictionEquals(-4)) == true))
        {
            UO.Print("Queued endpoint matches this component");
        }
        else
        {
            UO.Print("Different component or no player");
        }

        return null;
    }

    dynamic PredictionEquals(dynamic expected)
    {
        if (Truth(UO.Self() == 0))
        {
            return false;
        }

        var predicted = UO.PredictedZ();
        return Truth(predicted == expected);
    }

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

Implémentation de la commande

C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.

UO.PredictedZ() — UO.PredictedZ()

Paramètres: Aucun paramètre.

Résultat: int / Integer.

Pendant un appel:

Code interne de l’implémentation ; ce n’est pas un script autonome.

case "predictedz": return new InjectionValue(ReadPredictedCoordinate(2));

UO.SetRunMountTimer

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

Signatures C#

void UO.SetRunMountTimer(object? value);

Définit l'intervalle de pas pour courir à cheval. Utilisez-le pour ralentir intentionnellement ou revenir à la vitesse standard. Vous ne pouvez pas accélérer le mouvement au-delà du tempo standard avec cette commande.

Paramètres

  • value — Nombre entier requis de millisecondes. Plage 100..2000 ; les valeurs plus petites, y compris 0 et les valeurs négatives, montent jusqu'à 100, les valeurs plus grandes diminuent jusqu'à 2000.

Valeur de retour

void - aucune valeur. Appelez sur une ligne séparée. Pour lire l'espacement appliqué, utilisez UO.GetRunMountTimer(). Ceci ne constitue pas une confirmation de l'étape par le serveur.

Comportement

  • 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.
  • 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é.

Scripts C# autonomes

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.

Exemple simple

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

1. Restaurer le tempo standard - script direct

Paramètres et déroulement de l’exécution :

  • Value=100 — millisecondes. L'appel établit un mouvement ultérieur, mais ne démarre pas d'itinéraire.
UO.SetRunMountTimer(100);

2. Ralentir temporairement une demande de mouvement - fonction de script

Paramètres et déroulement de l’exécution :

  • Value=200 ajoute 100 ms à l'intervalle standard. Le changement s'applique uniquement aux courses à cheval. Par exemple, sélectionnez une direction libre.
  • UO.Step obtient Direction=2 et Running=true. Le code 7 ne peut signifier que tourner ; les autres codes ne sont pas true/false. finally restaure le paramètre précédent lors d'un arrêt normal ou d'une gestion des erreurs.
return  RunScenario();
 object? RunScenario()
{
    var previous = UO.GetRunMountTimer();
    try
    {
        UO.SetRunMountTimer(200);
        var stepResult = UO.Step(2, true);
        if (Truth(stepResult != 7))
        {
            UO.Print("Step was not confirmed: " + Convert.ToString(stepResult));
        }
    }
    finally
    {
        UO.SetRunMountTimer(previous);
    }

    return null;
}

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

3. Vérifier la protection contre une valeur trop faible - Classe de script

Paramètres et déroulement de l’exécution :

  • Après que Value=1 appliqué soit égal à 100. L'exemple ne déplace pas le caractère et restaure l'espacement d'origine.
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();
        try
        {
            UO.SetRunMountTimer(1);
            var applied = UO.GetRunMountTimer();
            UO.Print("Applied delay, ms: " + Convert.ToString(applied));
        }
        finally
        {
            UO.SetRunMountTimer(previous);
        }

        return null;
    }
}

Implémentation de la commande

C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.

UO.SetRunMountTimer(value) — UO.SetRunMountTimer(Any)

Paramètres: value (Any)

Résultat: void / Unit.

Pendant un appel:

Code interne de l’implémentation ; ce n’est pas un script autonome.

case "setrunmounttimer":

                    state.RunMountTimer = ClampMoveTimer(Arg(0), 100);

                    bridge.SetMovementTimers(state.RunMountTimer, state.RunUnmountTimer, state.WalkMountTimer, state.WalkUnmountTimer);

                    return InjectionValue.Unit;

UO.SetRunUnmountTimer

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

Signatures C#

void UO.SetRunUnmountTimer(object? value);

Définit l'intervalle de foulée de marche. Utilisez-le pour ralentir intentionnellement ou revenir à la vitesse standard. Vous ne pouvez pas accélérer le mouvement au-delà du tempo standard avec cette commande.

Paramètres

  • value — Nombre entier requis de millisecondes. Plage 200..2000 ; les valeurs plus petites, y compris 0 et les valeurs négatives, montent jusqu'à 200, les valeurs plus grandes diminuent jusqu'à 2000.

Valeur de retour

void - aucune valeur. Appelez sur une ligne séparée. Pour lire l'espacement appliqué, utilisez UO.GetRunUnmountTimer(). Ceci ne constitue pas une confirmation de l'étape par le serveur.

Comportement

  • 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.
  • 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é.

Scripts C# autonomes

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.

Exemple simple

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

1. Restaurer le tempo standard - script direct

Paramètres et déroulement de l’exécution :

  • Value=200 — millisecondes. L'appel établit un mouvement ultérieur, mais ne démarre pas d'itinéraire.
UO.SetRunUnmountTimer(200);

2. Ralentir temporairement une demande de mouvement - fonction de script

Paramètres et déroulement de l’exécution :

  • Value=300 ajoute 100 ms à l'intervalle standard. Le changement s'applique uniquement à la course à pied. Par exemple, sélectionnez une direction libre.
  • UO.Step obtient Direction=2 et Running=true. Le code 7 ne peut signifier que tourner ; les autres codes ne sont pas true/false. finally restaure le paramètre précédent lors d'un arrêt normal ou d'une gestion des erreurs.
return  RunScenario();
 object? RunScenario()
{
    var previous = UO.GetRunUnMountTimer();
    try
    {
        UO.SetRunUnmountTimer(300);
        var stepResult = UO.Step(2, true);
        if (Truth(stepResult != 7))
        {
            UO.Print("Step was not confirmed: " + Convert.ToString(stepResult));
        }
    }
    finally
    {
        UO.SetRunUnmountTimer(previous);
    }

    return null;
}

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

3. Vérifier la protection contre une valeur trop faible - Classe de script

Paramètres et déroulement de l’exécution :

  • Après que Value=1 appliqué soit égal à 200. L'exemple ne déplace pas le caractère et restaure l'espacement d'origine.
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();
        try
        {
            UO.SetRunUnmountTimer(1);
            var applied = UO.GetRunUnMountTimer();
            UO.Print("Applied delay, ms: " + Convert.ToString(applied));
        }
        finally
        {
            UO.SetRunUnmountTimer(previous);
        }

        return null;
    }
}

Implémentation de la commande

C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.

UO.SetRunUnmountTimer(value) — UO.SetRunUnmountTimer(Any)

Paramètres: value (Any)

Résultat: void / Unit.

Pendant un appel:

Code interne de l’implémentation ; ce n’est pas un script autonome.

case "setrununmounttimer":

                    state.RunUnmountTimer = ClampMoveTimer(Arg(0), 200);

                    bridge.SetMovementTimers(state.RunMountTimer, state.RunUnmountTimer, state.WalkMountTimer, state.WalkUnmountTimer);

                    return InjectionValue.Unit;

UO.SetWalkMountTimer

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

Signatures C#

void UO.SetWalkMountTimer(object? value);

Définit l'intervalle de pas pour la marche à cheval. Utilisez-le pour ralentir intentionnellement ou revenir à la vitesse standard. Vous ne pouvez pas accélérer le mouvement au-delà du tempo standard avec cette commande.

Paramètres

  • value — Nombre entier requis de millisecondes. Plage 200..2000 ; les valeurs plus petites, y compris 0 et les valeurs négatives, montent jusqu'à 200, les valeurs plus grandes diminuent jusqu'à 2000.

Valeur de retour

void - aucune valeur. Appelez sur une ligne séparée. Pour lire l'espacement appliqué, utilisez UO.GetWalkMountTimer(). Ceci ne constitue pas une confirmation de l'étape par le serveur.

Comportement

  • 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é.

Scripts C# autonomes

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.

Exemple simple

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

1. Restaurer le tempo standard - script direct

Paramètres et déroulement de l’exécution :

  • Value=200 — millisecondes. L'appel établit un mouvement ultérieur, mais ne démarre pas d'itinéraire.
UO.SetWalkMountTimer(200);

2. Ralentir temporairement une demande de mouvement - fonction de script

Paramètres et déroulement de l’exécution :

  • Value=300 ajoute 100 ms à l'intervalle standard. Le changement s'applique uniquement à l'équitation. Par exemple, sélectionnez une direction libre.
  • UO.Step obtient Direction=2 et Running=false. Le code 7 ne peut signifier que tourner ; les autres codes ne sont pas true/false. finally restaure le paramètre précédent lors d'un arrêt normal ou d'une gestion des erreurs.
return  RunScenario();
 object? RunScenario()
{
    var previous = UO.GetWalkMountTimer();
    try
    {
        UO.SetWalkMountTimer(300);
        var stepResult = UO.Step(2, false);
        if (Truth(stepResult != 7))
        {
            UO.Print("Step was not confirmed: " + Convert.ToString(stepResult));
        }
    }
    finally
    {
        UO.SetWalkMountTimer(previous);
    }

    return null;
}

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

3. Vérifier la protection contre une valeur trop faible - Classe de script

Paramètres et déroulement de l’exécution :

  • Après que Value=1 appliqué soit égal à 200. L'exemple ne déplace pas le caractère et restaure l'espacement d'origine.
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();
        try
        {
            UO.SetWalkMountTimer(1);
            var applied = UO.GetWalkMountTimer();
            UO.Print("Applied delay, ms: " + Convert.ToString(applied));
        }
        finally
        {
            UO.SetWalkMountTimer(previous);
        }

        return null;
    }
}

Implémentation de la commande

C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.

UO.SetWalkMountTimer(value) — UO.SetWalkMountTimer(Any)

Paramètres: value (Any)

Résultat: void / Unit.

Pendant un appel:

Code interne de l’implémentation ; ce n’est pas un script autonome.

case "setwalkmounttimer":

                    state.WalkMountTimer = ClampMoveTimer(Arg(0), 200);

                    bridge.SetMovementTimers(state.RunMountTimer, state.RunUnmountTimer, state.WalkMountTimer, state.WalkUnmountTimer);

                    return InjectionValue.Unit;

UO.SetWalkUnmountTimer

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

Signatures C#

void UO.SetWalkUnmountTimer(object? value);

Définit l'intervalle de pas de marche. Utilisez-le pour ralentir intentionnellement ou revenir à la vitesse standard. Vous ne pouvez pas accélérer le mouvement au-delà du tempo standard avec cette commande.

Paramètres

  • value — Nombre entier requis de millisecondes. Plage 400..2000 ; les valeurs plus petites, y compris 0 et les valeurs négatives, montent jusqu'à 400, les valeurs plus grandes diminuent jusqu'à 2000.

Valeur de retour

void - aucune valeur. Appelez sur une ligne séparée. Pour lire l'espacement appliqué, utilisez UO.GetWalkUnmountTimer(). Ceci ne constitue pas une confirmation de l'étape par le serveur.

Comportement

  • 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é.

Scripts C# autonomes

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.

Exemple simple

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

1. Restaurer le tempo standard - script direct

Paramètres et déroulement de l’exécution :

  • Value=400 — millisecondes. L'appel établit un mouvement ultérieur, mais ne démarre pas d'itinéraire.
UO.SetWalkUnmountTimer(400);

2. Ralentir temporairement une demande de mouvement - fonction de script

Paramètres et déroulement de l’exécution :

  • Value=500 ajoute 100 ms à l'intervalle standard. Le changement s'applique uniquement à la marche. Par exemple, sélectionnez une direction libre.
  • UO.Step obtient Direction=2 et Running=false. Le code 7 ne peut signifier que tourner ; les autres codes ne sont pas true/false. finally restaure le paramètre précédent lors d'un arrêt normal ou d'une gestion des erreurs.
return  RunScenario();
 object? RunScenario()
{
    var previous = UO.GetWalkUnmountTimer();
    try
    {
        UO.SetWalkUnmountTimer(500);
        var stepResult = UO.Step(2, false);
        if (Truth(stepResult != 7))
        {
            UO.Print("Step was not confirmed: " + Convert.ToString(stepResult));
        }
    }
    finally
    {
        UO.SetWalkUnmountTimer(previous);
    }

    return null;
}

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

3. Vérifier la protection contre une valeur trop faible - Classe de script

Paramètres et déroulement de l’exécution :

  • Après que Value=1 appliqué soit égal à 400. L'exemple ne déplace pas le caractère et restaure l'espacement d'origine.
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();
        try
        {
            UO.SetWalkUnmountTimer(1);
            var applied = UO.GetWalkUnmountTimer();
            UO.Print("Applied delay, ms: " + Convert.ToString(applied));
        }
        finally
        {
            UO.SetWalkUnmountTimer(previous);
        }

        return null;
    }
}

Implémentation de la commande

C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.

UO.SetWalkUnmountTimer(value) — UO.SetWalkUnmountTimer(Any)

Paramètres: value (Any)

Résultat: void / Unit.

Pendant un appel:

Code interne de l’implémentation ; ce n’est pas un script autonome.

case "setwalkunmounttimer":

                    state.WalkUnmountTimer = ClampMoveTimer(Arg(0), 400);

                    bridge.SetMovementTimers(state.RunMountTimer, state.RunUnmountTimer, state.WalkMountTimer, state.WalkUnmountTimer);

                    return InjectionValue.Unit;

UO.Step

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

Signatures C#

dynamic UO.Step(object? direction, object? running);

Demande une seule étape/rotation et, si une étape a été envoyée, attend la confirmation du serveur.

Paramètres

  • direction — Direction 0=N, 1=NE, 2=E, 3=SE, 4=S, 5=SW, 6=W, 7=NW. L'implémentation applique un &7; utilisez 0..7 pour plus de clarté.
  • 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.

Valeur de retour

int : 7 — le pas est confirmé ou seul un tour est effectué ; 5 — le serveur a rejeté l'étape ; 4 — le délai de confirmation a expiré (jusqu'à 10000 ms) ; 3 — étape bloquée par le client ; 2 — la file d'attente est pleine ; 0 - panne générale, arrêt ou endurance insuffisante. Ce n'est pas true/false : par exemple, le code non nul 5 signifie échec.

Comportement

  • Une équipe peut faire pivoter le personnage en premier ; cela ne signifie pas nécessairement passer à la case suivante.
  • moveCheckStamina, moveExitOnDisconnect et moveOpenDoor sont pris en compte. L'interdiction du serveur et l'interdiction locale sont différentes.
  • Ne répétez pas la commande en boucle sans analyser le résultat et UO.Wait : La file d'attente de mouvements et la vitesse du serveur sont limitées.
  • QueueStep sur le flux de jeu vérifie le joueur, la connexion, la direction, la file d'attente, le tempo et le trafic local. Avant Player.Walk, chaque appel enregistre séparément les générations Confirm/Deny de sa séquence et de Walker ; renvoie ensuite le résultat avec cet instantané. Step et en attente StepControlled vérifient uniquement cette paire stockée, pas les champs communs de la requête suivante ; le joueur/marcheur remplaçant termine l'attente par un refus général. La confirmation d'une autre commande régulière ne confirme pas cette étape. La rotation sans mouvement reste un cas à part.

Scripts C# autonomes

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.

Exemple simple

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

1. Étape Est - Script Direct

Paramètres et déroulement de l’exécution :

  • Direction=2 — E, Running=false — étape.
  • Le code exact 7 est vérifié ; Pour confirmer le mouvement, comparez X/Y avant et après.
var result = UO.Step(2, false);
if (Truth(result == 7))
{
    UO.Print("Step accepted or turn completed");
}
else
{
    UO.Print("Movement status: " + Convert.ToString(result));
}

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

2. Distinguer la rotation de la traduction - fonction de script

Paramètres et déroulement de l’exécution :

  • Direction=0 — N. Les coordonnées sont lues avant et après l'appel.
  • Une position inchangée est possible en cas de rotation ou de défaillance, le résultat est donc nécessaire séparément.
return  RunScenario();
 object? RunScenario()
{
    var x = UO.GetX();
    var y = UO.GetY();
    var result = UO.Step(0, false);
    if (Truth(UO.GetX() == x) && Truth(UO.GetY() == y))
    {
        UO.Print("Position unchanged; status=" + Convert.ToString(result));
    }

    return null;
}

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

3. Gérer les pannes de serveur lors de l'exécution - classe de script

Paramètres et déroulement de l’exécution :

  • Direction=4 — S, Running=true.
  • Code 5—échec du serveur. UO.Wait=250 ms spécifie une pause pour le script et ne garantit pas que la prochaine tentative réussira.

Vitesse de conduite standard

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 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 result = UO.Step(4, true);
        if (Truth(result == 5))
        {
            UO.Print("Server denied the step");
            await Delay(250);
        }

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

Implémentation de la commande

C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.

UO.Step(direction, running) — UO.Step(Any,Any)

Paramètres: direction (Any), running (Any)

Résultat: dynamic / Any.

Pendant un appel:

Code interne de l’implémentation ; ce n’est pas un script autonome.

case "step":

                    if (state.MoveExitOnDisconnect != 0 && bridge.IsOnline() == 0)

                        return new InjectionValue(0);

                    if (state.MoveCheckStamina > 0 && bridge.Stamina < state.MoveCheckStamina)

                        return new InjectionValue(0);

                    if (state.MoveOpenDoor != 0)

                        bridge.OpenDoor();

                    return new InjectionValue(bridge.Step(Arg(0) & 7, Arg(1) != 0));

UO.StepQ

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

Signatures C#

int UO.StepQ(object? direction, object? run);
int UO.StepQ(object? direction, object? run, object? timeout);
int UO.StepQ(object? direction, object? run, object? timeout, object? queue);
int UO.StepQ(object? direction, object? run, object? timeout, object? queue, object? waitForAck);

Demande une étape dans la file d'attente ; le formulaire complémentaire peut attendre que la file d'attente se libère et soit confirmée.

Paramètres

  • direction — Direction 0=N, 1=NE, 2=E, 3=SE, 4=S, 5=SW, 6=W, 7=NW. L'implémentation applique un &7; utilisez 0..7 pour plus de clarté.
  • run - 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 — Temps d'attente de file d'attente facultatif en ms. 0/negative n'attend pas la sortie ; avec waitForAck=true et timeout=0 la confirmation est attendue avant 10000 ms. Si la valeur est positive, l'attente de confirmation reçoit une période distincte de même durée.
  • queue — Indicateur facultatif, par défaut true. false transmet forcePacket lors de la demande d'une étape ; ne remplace pas les restrictions du serveur et n'efface pas la file d'attente accumulée.
  • waitForAck - false/absent - renvoie immédiatement le résultat de l'instruction. true — pour l'étape envoyée, attendre la confirmation/refus.

Valeur de retour

int sans waitForAck : 0..255 — séquence de la demande envoyée, y compris 0 valide ; 256 - tourner uniquement ; -2 — obstacle sur le client ; -1 - panne générale/file d'attente pleine/arrêt/endurance. Avec waitForAck=true : 7 - confirmation, 5 - panne du serveur, 4 - timeout ; -1/-2/256 conservent le sens précédent. Le numéro 7 sous la forme sans attente est une séquence, pas une confirmation. Vérifiez les codes numériques spécifiques ; if (résultat) pour int dans C# n'est pas valide.

Comportement

  • Une équipe peut faire pivoter le personnage en premier ; cela ne signifie pas nécessairement passer à la case suivante.
  • moveCheckStamina, moveExitOnDisconnect et moveOpenDoor sont pris en compte. L'interdiction du serveur et l'interdiction locale sont différentes.
  • Ne répétez pas la commande en boucle sans analyser le résultat et UO.Wait : La file d'attente de mouvements et la vitesse du serveur sont limitées.
  • Sans attendre, la commande ne confirme pas le changement de position. LastStepQUsedDoor indique une tentative d'ouverture de la porte, pas le résultat de l'étape.
  • QueueStep sur le flux de jeu vérifie le joueur, la connexion, la direction, la file d'attente, le tempo et le trafic local. Avant Player.Walk, chaque appel enregistre séparément les générations Confirm/Deny de sa séquence et de Walker ; renvoie ensuite le résultat avec cet instantané. Step et en attente StepControlled vérifient uniquement cette paire stockée, pas les champs communs de la requête suivante ; le joueur/marcheur remplaçant termine l'attente par un refus général. La confirmation d'une autre commande régulière ne confirme pas cette étape. La rotation sans mouvement reste un cas à part.

Scripts C# autonomes

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.

Exemple simple

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

1. Obtenez la séquence sans attendre - script direct

Paramètres et déroulement de l’exécution :

  • direction=2 — E, run=false. Deux arguments signifient un réglage normal sans attendre de confirmation.
  • séquence=0 est un succès de mise en scène valide ; séquence=256 signifie rotation.
var sequence = UO.StepQ(2, false);
if (Truth(sequence >= 0) && Truth(sequence <= 255))
{
    UO.Print("Queued sequence: " + Convert.ToString(sequence));
}
else
{
    UO.Print("Queue status: " + Convert.ToString(sequence));
}

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

2. Attendre la confirmation - fonction de script

Paramètres et déroulement de l’exécution :

  • direction=4 — S, run=true, timeout=1500 MS. file d'attente =true, waitForAck=true.
  • L'attente d'un siège puis l'accusé de réception peuvent prendre jusqu'à deux intervalles 1500 ms. 256 nécessite une prise en compte séparée de la rotation.
return  RunScenario();
 object? RunScenario()
{
    var status = UO.StepQ(4, true, 1500, true, true);
    if (Truth(status == 7))
    {
        UO.Print("Server confirmed");
    }
    else
    {
        UO.Print("Step status: " + Convert.ToString(status));
    }

    return null;
}

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

3. Traiter séparément le mur local - classe de script

Paramètres et déroulement de l’exécution :

  • direction=6 — W, run=false ; timeout=0 ne fait pas la queue ; queue=false requêtes forcePacket, waitForAck=false.
  • ForcePacket ne donne pas le droit de traverser le mur. Pour -2, calculez un itinéraire différent au lieu de l'envoyer à nouveau vers la même cellule.

Vitesse de conduite standard

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 status = UO.StepQ(6, false, 0, false, false);
        if (Truth(status == -2))
        {
            UO.Print("Local obstacle; calculate another route");
        }

        return null;
    }

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

Implémentation de la commande

C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.

UO.StepQ(direction, run) — UO.StepQ(Any,Any)

Paramètres: direction (Any), run (Any)

Résultat: int / Integer.

Pendant un appel:

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(CompactStepQ(values))

UO.StepQ(direction, run, timeout) — UO.StepQ(Any,Any,Any)

Paramètres: direction (Any), run (Any), timeout (Any)

Résultat: int / Integer.

Pendant un appel:

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(CompactStepQ(values))

UO.StepQ(direction, run, timeout, queue) — UO.StepQ(Any,Any,Any,Any)

Paramètres: direction (Any), run (Any), timeout (Any), queue (Any)

Résultat: int / Integer.

Pendant un appel:

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(CompactStepQ(values))

UO.StepQ(direction, run, timeout, queue, waitForAck) — UO.StepQ(Any,Any,Any,Any,Any)

Paramètres: direction (Any), run (Any), timeout (Any), queue (Any), waitForAck (Any)

Résultat: int / Integer.

Pendant un appel:

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(CompactStepQ(values))

UO.moveBetweenTwoCorners

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

Signatures C#

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

Résolution diagonale avec deux carrés latéraux bloqués.

Paramètres

  • value — Nouvelle valeur facultative. 0 interdit, non nul devient 1. Le serveur peut rejeter une telle passe quelle que soit la configuration du client.

Valeur de retour

int est la valeur actuellement stockée. Sans argument, il lit seulement ; avec un argument renvoie la valeur après avoir appliqué les règles ci-dessus. Il s’agit d’un paramètre et non du résultat d’un mouvement.

Comportement

  • Le paramètre est stocké dans l'état d'exécution et est utilisé par les commandes correspondantes au démarrage ; la modification n'écrase pas automatiquement le chemin déjà construit.
  • Le retour de la valeur d'origine est affiché pour une exécution normale. Après un crash, les lignes de récupération suivantes ne sont pas exécutées.
  • 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é.

Scripts C# autonomes

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.

Exemple simple

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

1. Paramètres de lecture - script direct

Paramètres et déroulement de l’exécution :

  • Il n’y a pas de disputes, l’État ne change pas.
  • value est la valeur numérique de ce paramètre.
var value = UO.moveBetweenTwoCorners();
UO.Print(Convert.ToString(value));

2. Définir une valeur explicite - Fonction de script

Paramètres et déroulement de l’exécution :

  • valeur=0. 0 interdit, non nul devient 1. Le serveur peut rejeter une telle passe quelle que soit la configuration du client.
  • appliqué montre la valeur économisée, et non la réussite de l'objectif.
return  RunScenario();
 object? RunScenario()
{
    var applied = UO.moveBetweenTwoCorners(0);
    UO.Print("Applied: " + Convert.ToString(applied));
    return null;
}

3. Appliquer à une section du script - classe de script

Paramètres et déroulement de l’exécution :

  • précédent stocke le paramètre initial ; NewMoveXY est limité à 3000 ms.
  • La dernière commande restaure le réglage après le retour du mouvement normal.
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.moveBetweenTwoCorners();
        UO.moveBetweenTwoCorners(0);
        var ok = UO.NewMoveXY(UO.GetX() + 2, UO.GetY(), true, 0, false, 0, 3000);
        UO.moveBetweenTwoCorners(previous);
        UO.Print(Convert.ToString(ok));
        return null;
    }
}

Implémentation de la commande

C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.

UO.moveBetweenTwoCorners() — UO.moveBetweenTwoCorners()

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 "movebetweentwocorners":

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

                    return new InjectionValue(state.MoveBetweenTwoCorners);

UO.moveBetweenTwoCorners(value) — UO.moveBetweenTwoCorners(Any)

Paramètres: value (Any)

Résultat: dynamic / Any.

Pendant un appel:

Code interne de l’implémentation ; ce n’est pas un script autonome.

case "movebetweentwocorners":

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

                    return new InjectionValue(state.MoveBetweenTwoCorners);

UO.moveCheckStamina

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

Signatures C#

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

Endurance minimale pour les commandes de mouvement.

Paramètres

  • value — Nouvelle valeur facultative. Entier >=0 ; le négatif devient 0. Zéro désactive la vérification du seuil.

Valeur de retour

int est la valeur actuellement stockée. Sans argument, il lit seulement ; avec un argument renvoie la valeur après avoir appliqué les règles ci-dessus. Il s’agit d’un paramètre et non du résultat d’un mouvement.

Comportement

  • Le paramètre est stocké dans l'état d'exécution et est utilisé par les commandes correspondantes au démarrage ; la modification n'écrase pas automatiquement le chemin déjà construit.
  • Le retour de la valeur d'origine est affiché pour une exécution normale. Après un crash, les lignes de récupération suivantes ne sont pas exécutées.
  • La valeur par défaut est 1. La valeur 0 désactive cette vérification locale ; positif définit l'endurance minimale. En dessous du seuil, le lancement est rejeté ou le mouvement est arrêté plutôt que d'attendre que l'endurance soit restaurée.
  • 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é.

Scripts C# autonomes

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.

Exemple simple

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

1. Paramètres de lecture - script direct

Paramètres et déroulement de l’exécution :

  • Il n’y a pas de disputes, l’État ne change pas.
  • value est la valeur numérique de ce paramètre.
var value = UO.moveCheckStamina();
UO.Print(Convert.ToString(value));

2. Définir une valeur explicite - Fonction de script

Paramètres et déroulement de l’exécution :

  • valeur=15. Entier >=0 ; le négatif devient 0. Zéro désactive la vérification du seuil.
  • appliqué montre la valeur économisée, et non la réussite de l'objectif.
return  RunScenario();
 object? RunScenario()
{
    var applied = UO.moveCheckStamina(15);
    UO.Print("Applied: " + Convert.ToString(applied));
    return null;
}

3. Appliquer à une section du script - classe de script

Paramètres et déroulement de l’exécution :

  • précédent stocke le paramètre initial ; NewMoveXY est limité à 3000 ms.
  • La dernière commande restaure le réglage après le retour du mouvement normal.
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.NewMoveXY(UO.GetX() + 2, UO.GetY(), true, 0, false, 0, 3000);
        UO.moveCheckStamina(previous);
        UO.Print(Convert.ToString(ok));
        return null;
    }
}

Implémentation de la commande

C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.

UO.moveCheckStamina() — UO.moveCheckStamina()

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 "movecheckstamina": if (arguments.Length > 0) state.MoveCheckStamina = Math.Max(0, Arg(0)); return new InjectionValue(state.MoveCheckStamina);

UO.moveCheckStamina(value) — UO.moveCheckStamina(Any)

Paramètres: value (Any)

Résultat: dynamic / Any.

Pendant un appel:

Code interne de l’implémentation ; ce n’est pas un script autonome.

case "movecheckstamina": if (arguments.Length > 0) state.MoveCheckStamina = Math.Max(0, Arg(0)); return new InjectionValue(state.MoveCheckStamina);

UO.moveExitOnDisconnect

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

Signatures C#

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

Arrêter/refuser le mouvement lorsque la connexion est déconnectée.

Paramètres

  • value — Nouvelle valeur facultative. 0 s'éteint, non nul devient 1. La désactivation de la vérification vous empêche de vous déplacer sur le serveur sans connexion.

Valeur de retour

int est la valeur actuellement stockée. Sans argument, il lit seulement ; avec un argument renvoie la valeur après avoir appliqué les règles ci-dessus. Il s’agit d’un paramètre et non du résultat d’un mouvement.

Comportement

  • Le paramètre est stocké dans l'état d'exécution et est utilisé par les commandes correspondantes au démarrage ; la modification n'écrase pas automatiquement le chemin déjà construit.
  • Le retour de la valeur d'origine est affiché pour une exécution normale. Après un crash, les lignes de récupération suivantes ne sont pas exécutées.
  • 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é.

Scripts C# autonomes

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.

Exemple simple

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

1. Paramètres de lecture - script direct

Paramètres et déroulement de l’exécution :

  • Il n’y a pas de disputes, l’État ne change pas.
  • value est la valeur numérique de ce paramètre.
var value = UO.moveExitOnDisconnect();
UO.Print(Convert.ToString(value));

2. Définir une valeur explicite - Fonction de script

Paramètres et déroulement de l’exécution :

  • valeur=1. 0 s'éteint, non nul devient 1. La désactivation de la vérification vous empêche de vous déplacer sur le serveur sans connexion.
  • appliqué montre la valeur économisée, et non la réussite de l'objectif.
return  RunScenario();
 object? RunScenario()
{
    var applied = UO.moveExitOnDisconnect(1);
    UO.Print("Applied: " + Convert.ToString(applied));
    return null;
}

3. Appliquer à une section du script - classe de script

Paramètres et déroulement de l’exécution :

  • précédent stocke le paramètre initial ; NewMoveXY est limité à 3000 ms.
  • La dernière commande restaure le réglage après le retour du mouvement normal.
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.moveExitOnDisconnect();
        UO.moveExitOnDisconnect(1);
        var ok = UO.NewMoveXY(UO.GetX() + 2, UO.GetY(), true, 0, false, 0, 3000);
        UO.moveExitOnDisconnect(previous);
        UO.Print(Convert.ToString(ok));
        return null;
    }
}

Implémentation de la commande

C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.

UO.moveExitOnDisconnect() — UO.moveExitOnDisconnect()

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 "moveexitondisconnect": if (arguments.Length > 0) state.MoveExitOnDisconnect = Arg(0) != 0 ? 1 : 0; return new InjectionValue(state.MoveExitOnDisconnect);

UO.moveExitOnDisconnect(value) — UO.moveExitOnDisconnect(Any)

Paramètres: value (Any)

Résultat: dynamic / Any.

Pendant un appel:

Code interne de l’implémentation ; ce n’est pas un script autonome.

case "moveexitondisconnect": if (arguments.Length > 0) state.MoveExitOnDisconnect = Arg(0) != 0 ? 1 : 0; return new InjectionValue(state.MoveExitOnDisconnect);

UO.moveHeuristicMult

Réglages initiaux de recherche de chemin

Dans un nouveau contexte de script, UO.moveHeuristicMult() vaut 120 et UO.moveTurnCost() vaut 14. Une valeur explicitement définie par le script est conservée pour ses commandes de déplacement suivantes. Le multiplicateur 100 utilise l’estimation habituelle incluant les diagonales ; une valeur supérieure accélère généralement la recherche sans garantir le chemin le plus court. Une valeur inférieure peut fortement augmenter le temps de calcul. Le coût de virage 0 supprime la pénalité supplémentaire des changements de direction. Ces réglages concernent la recherche du chemin, pas la vitesse du personnage ni la limite UO.LimitMove.

int previousHeuristic = (int)UO.moveHeuristicMult();
int previousTurnCost = (int)UO.moveTurnCost();
try
{
    UO.moveHeuristicMult(120);
    UO.moveTurnCost(14);
    UO.Print($"Heuristic: {UO.moveHeuristicMult()}, turn cost: {UO.moveTurnCost()}");
}
finally
{
    UO.moveHeuristicMult(previousHeuristic);
    UO.moveTurnCost(previousTurnCost);
}

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

Signatures C#

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

Multiplicateur heuristique Pathfinder en pourcentage.

Paramètres

  • value — Nouvelle valeur facultative. L'entier >=0 est conservé ; avant de chercher au moins 1. La valeur 100 correspond à l'estimation habituelle ; >100 peut préférer une recherche plus rapide sans garantie de coût minimum. Lorsque Optimized=false, 1 est utilisé.

Valeur de retour

int est la valeur actuellement stockée. Sans argument, il lit seulement ; avec un argument renvoie la valeur après avoir appliqué les règles ci-dessus. Il s’agit d’un paramètre et non du résultat d’un mouvement.

Comportement

  • Le paramètre est stocké dans l'état d'exécution et est utilisé par les commandes correspondantes au démarrage ; la modification n'écrase pas automatiquement le chemin déjà construit.
  • Le retour de la valeur d'origine est affiché pour une exécution normale. Après un crash, les lignes de récupération suivantes ne sont pas exécutées.
  • 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é.

Scripts C# autonomes

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.

Exemple simple

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

1. Paramètres de lecture - script direct

Paramètres et déroulement de l’exécution :

  • Il n’y a pas de disputes, l’État ne change pas.
  • value est la valeur numérique de ce paramètre.
var value = UO.moveHeuristicMult();
UO.Print(Convert.ToString(value));

2. Définir une valeur explicite - Fonction de script

Paramètres et déroulement de l’exécution :

  • valeur=100. L'entier >=0 est conservé ; avant de chercher au moins 1. La valeur 100 correspond à l'estimation habituelle ; >100 peut préférer une recherche plus rapide sans garantie de coût minimum. Lorsque Optimized=false, 1 est utilisé.
  • appliqué montre la valeur économisée, et non la réussite de l'objectif.
return  RunScenario();
 object? RunScenario()
{
    var applied = UO.moveHeuristicMult(100);
    UO.Print("Applied: " + Convert.ToString(applied));
    return null;
}

3. Appliquer à une section du script - classe de script

Paramètres et déroulement de l’exécution :

  • précédent stocke le paramètre initial ; NewMoveXY est limité à 3000 ms.
  • La dernière commande restaure le réglage après le retour du mouvement normal.
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.moveHeuristicMult();
        UO.moveHeuristicMult(100);
        var ok = UO.NewMoveXY(UO.GetX() + 2, UO.GetY(), true, 0, false, 0, 3000);
        UO.moveHeuristicMult(previous);
        UO.Print(Convert.ToString(ok));
        return null;
    }
}

Implémentation de la commande

C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.

UO.moveHeuristicMult() — UO.moveHeuristicMult()

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 "moveheuristicmult": if (arguments.Length > 0) state.MoveHeuristicMultiplier = Math.Max(0, Arg(0)); return new InjectionValue(state.MoveHeuristicMultiplier);

UO.moveHeuristicMult(value) — UO.moveHeuristicMult(Any)

Paramètres: value (Any)

Résultat: dynamic / Any.

Pendant un appel:

Code interne de l’implémentation ; ce n’est pas un script autonome.

case "moveheuristicmult": if (arguments.Length > 0) state.MoveHeuristicMultiplier = Math.Max(0, Arg(0)); return new InjectionValue(state.MoveHeuristicMultiplier);

UO.moveOpenDoor

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

Signatures C#

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

Tentatives d'ouvrir les portes dans le sens de la marche.

Paramètres

  • value — Nouvelle valeur facultative. 0 s'éteint, non nul devient 1. Un openDoors explicite dans NewMoveXY/MoveXYZ remplace cet indicateur pour la durée de l'appel.

Valeur de retour

int est la valeur actuellement stockée. Sans argument, il lit seulement ; avec un argument renvoie la valeur après avoir appliqué les règles ci-dessus. Il s’agit d’un paramètre et non du résultat d’un mouvement.

Comportement

  • Le paramètre est stocké dans l'état d'exécution et est utilisé par les commandes correspondantes au démarrage ; la modification n'écrase pas automatiquement le chemin déjà construit.
  • Le retour de la valeur d'origine est affiché pour une exécution normale. Après un crash, les lignes de récupération suivantes ne sont pas exécutées.
  • La valeur par défaut est 0. En 1 les cellules de porte sont considérées comme praticables pendant A* ; une tentative d'ouverture d'une porte adjacente spécifique est effectuée avant l'étape. S'il n'y a aucun objet porte connu, la requête OpenDoor est utilisée.
  • Ce drapeau ne ferme pas la porte lui-même. Fermer une porte ouverte par un personnage est un paramètre client distinct ; une porte verrouillée ou une interdiction de serveur peut perturber l'itinéraire.
  • 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é.

Scripts C# autonomes

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.

Exemple simple

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

1. Paramètres de lecture - script direct

Paramètres et déroulement de l’exécution :

  • Il n’y a pas de disputes, l’État ne change pas.
  • value est la valeur numérique de ce paramètre.
var value = UO.moveOpenDoor();
UO.Print(Convert.ToString(value));

2. Définir une valeur explicite - Fonction de script

Paramètres et déroulement de l’exécution :

  • valeur=1. 0 s'éteint, non nul devient 1. Un openDoors explicite dans NewMoveXY/MoveXYZ remplace cet indicateur pour la durée de l'appel.
  • appliqué montre la valeur économisée, et non la réussite de l'objectif.
return  RunScenario();
 object? RunScenario()
{
    var applied = UO.moveOpenDoor(1);
    UO.Print("Applied: " + Convert.ToString(applied));
    return null;
}

3. Appliquer à une section du script - classe de script

Paramètres et déroulement de l’exécution :

  • précédent stocke le paramètre initial ; NewMoveXY est limité à 3000 ms.
  • La dernière commande restaure le réglage après le retour du mouvement normal.
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.moveOpenDoor();
        UO.moveOpenDoor(1);
        var ok = UO.NewMoveXY(UO.GetX() + 2, UO.GetY(), true, 0, false, 0, 3000);
        UO.moveOpenDoor(previous);
        UO.Print(Convert.ToString(ok));
        return null;
    }
}

Implémentation de la commande

C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.

UO.moveOpenDoor() — UO.moveOpenDoor()

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 "moveopendoor": if (arguments.Length > 0) state.MoveOpenDoor = Arg(0) != 0 ? 1 : 0; return new InjectionValue(state.MoveOpenDoor);

UO.moveOpenDoor(value) — UO.moveOpenDoor(Any)

Paramètres: value (Any)

Résultat: dynamic / Any.

Pendant un appel:

Code interne de l’implémentation ; ce n’est pas un script autonome.

case "moveopendoor": if (arguments.Length > 0) state.MoveOpenDoor = Arg(0) != 0 ? 1 : 0; return new InjectionValue(state.MoveOpenDoor);

UO.moveThroughCorner

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

Signatures C#

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

Résolution de la diagonale entre les cellules avec une cellule latérale bloquée.

Paramètres

  • value — Nouvelle valeur facultative. 0 interdit, non nul devient 1. Si les deux cases latérales sont bloquées, moveBetweenTwoCorners est appliqué.

Valeur de retour

int est la valeur actuellement stockée. Sans argument, il lit seulement ; avec un argument renvoie la valeur après avoir appliqué les règles ci-dessus. Il s’agit d’un paramètre et non du résultat d’un mouvement.

Comportement

  • Le paramètre est stocké dans l'état d'exécution et est utilisé par les commandes correspondantes au démarrage ; la modification n'écrase pas automatiquement le chemin déjà construit.
  • Le retour de la valeur d'origine est affiché pour une exécution normale. Après un crash, les lignes de récupération suivantes ne sont pas exécutées.
  • 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é.

Scripts C# autonomes

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.

Exemple simple

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

1. Paramètres de lecture - script direct

Paramètres et déroulement de l’exécution :

  • Il n’y a pas de disputes, l’État ne change pas.
  • value est la valeur numérique de ce paramètre.
var value = UO.moveThroughCorner();
UO.Print(Convert.ToString(value));

2. Définir une valeur explicite - Fonction de script

Paramètres et déroulement de l’exécution :

  • valeur=0. 0 interdit, non nul devient 1. Si les deux cases latérales sont bloquées, moveBetweenTwoCorners est appliqué.
  • appliqué montre la valeur économisée, et non la réussite de l'objectif.
return  RunScenario();
 object? RunScenario()
{
    var applied = UO.moveThroughCorner(0);
    UO.Print("Applied: " + Convert.ToString(applied));
    return null;
}

3. Appliquer à une section du script - classe de script

Paramètres et déroulement de l’exécution :

  • précédent stocke le paramètre initial ; NewMoveXY est limité à 3000 ms.
  • La dernière commande restaure le réglage après le retour du mouvement normal.
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.moveThroughCorner();
        UO.moveThroughCorner(0);
        var ok = UO.NewMoveXY(UO.GetX() + 2, UO.GetY(), true, 0, false, 0, 3000);
        UO.moveThroughCorner(previous);
        UO.Print(Convert.ToString(ok));
        return null;
    }
}

Implémentation de la commande

C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.

UO.moveThroughCorner() — UO.moveThroughCorner()

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 "movethroughcorner": if (arguments.Length > 0) state.MoveThroughCorner = Arg(0) != 0 ? 1 : 0; return new InjectionValue(state.MoveThroughCorner);

UO.moveThroughCorner(value) — UO.moveThroughCorner(Any)

Paramètres: value (Any)

Résultat: dynamic / Any.

Pendant un appel:

Code interne de l’implémentation ; ce n’est pas un script autonome.

case "movethroughcorner": if (arguments.Length > 0) state.MoveThroughCorner = Arg(0) != 0 ? 1 : 0; return new InjectionValue(state.MoveThroughCorner);

UO.moveThroughNPC

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

Signatures C#

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

Autoriser les tentatives de passage à travers les personnages.

Paramètres

  • Seuil numérique d’endurance : une tentative de passage est permise si Stamina actuelle >= seuil. Valeur initiale 1000 ; 0 permet la tentative quelle que soit l’endurance. Le serveur peut refuser le déplacement.

Valeur de retour

int est la valeur actuellement stockée. Sans argument, il lit seulement ; avec un argument renvoie la valeur après avoir appliqué les règles ci-dessus. Il s’agit d’un paramètre et non du résultat d’un mouvement.

Comportement

  • Le paramètre est stocké dans l'état d'exécution et est utilisé par les commandes correspondantes au démarrage ; la modification n'écrase pas automatiquement le chemin déjà construit.
  • Le retour de la valeur d'origine est affiché pour une exécution normale. Après un crash, les lignes de récupération suivantes ne sont pas exécutées.
  • Seuil numérique d’endurance : une tentative de passage est permise si Stamina actuelle >= seuil. Valeur initiale 1000 ; 0 permet la tentative quelle que soit l’endurance. Le serveur peut refuser le déplacement.
  • 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é.

Scripts C# autonomes

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.

Exemple simple

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

1. Paramètres de lecture - script direct

Paramètres et déroulement de l’exécution :

  • Il n’y a pas de disputes, l’État ne change pas.
  • value est la valeur numérique de ce paramètre.
var value = UO.moveThroughNPC();
UO.Print(Convert.ToString(value));

2. Définir une valeur explicite - Fonction de script

Paramètres et déroulement de l’exécution :

  • valeur=0. Entier >=0, négatif devient 0 ; le positif permet la tentative. Un avoidMobiles explicite spécifie la contrainte inverse pour un seul appel.
  • appliqué montre la valeur économisée, et non la réussite de l'objectif.
return  RunScenario();
 object? RunScenario()
{
    var applied = UO.moveThroughNPC(0);
    UO.Print("Applied: " + Convert.ToString(applied));
    return null;
}

3. Appliquer à une section du script - classe de script

Paramètres et déroulement de l’exécution :

  • précédent stocke le paramètre initial ; NewMoveXY est limité à 3000 ms.
  • La dernière commande restaure le réglage après le retour du mouvement normal.
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.moveThroughNPC();
        UO.moveThroughNPC(0);
        var ok = UO.NewMoveXY(UO.GetX() + 2, UO.GetY(), true, 0, false, 0, 3000);
        UO.moveThroughNPC(previous);
        UO.Print(Convert.ToString(ok));
        return null;
    }
}

Implémentation de la commande

C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.

UO.moveThroughNPC() — UO.moveThroughNPC()

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 "movethroughnpc": if (arguments.Length > 0) state.MoveThroughNpc = Math.Max(0, Arg(0)); return new InjectionValue(state.MoveThroughNpc);

UO.moveThroughNPC(value) — UO.moveThroughNPC(Any)

Paramètres: value (Any)

Résultat: dynamic / Any.

Pendant un appel:

Code interne de l’implémentation ; ce n’est pas un script autonome.

case "movethroughnpc": if (arguments.Length > 0) state.MoveThroughNpc = Math.Max(0, Arg(0)); return new InjectionValue(state.MoveThroughNpc);

UO.moveTurnCost

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

Signatures C#

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

Coût supplémentaire du changement de direction lors de la recherche d'un chemin.

Paramètres

  • value — Nouvelle valeur facultative. Entier >=0, négatif devient 0. C'est le poids du parcours, pas des millisecondes : un pas droit coûte 10, un pas en diagonale 14, et c'est un ajout par tour.

Valeur de retour

int est la valeur actuellement stockée. Sans argument, il lit seulement ; avec un argument renvoie la valeur après avoir appliqué les règles ci-dessus. Il s’agit d’un paramètre et non du résultat d’un mouvement.

Comportement

  • Le paramètre est stocké dans l'état d'exécution et est utilisé par les commandes correspondantes au démarrage ; la modification n'écrase pas automatiquement le chemin déjà construit.
  • Le retour de la valeur d'origine est affiché pour une exécution normale. Après un crash, les lignes de récupération suivantes ne sont pas exécutées.
  • 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é.

Scripts C# autonomes

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.

Exemple simple

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

1. Paramètres de lecture - script direct

Paramètres et déroulement de l’exécution :

  • Il n’y a pas de disputes, l’État ne change pas.
  • value est la valeur numérique de ce paramètre.
var value = UO.moveTurnCost();
UO.Print(Convert.ToString(value));

2. Définir une valeur explicite - Fonction de script

Paramètres et déroulement de l’exécution :

  • valeur=14. Entier >=0, négatif devient 0. C'est le poids du parcours, pas des millisecondes : un pas droit coûte 10, un pas en diagonale 14, et c'est un ajout par tour.
  • appliqué montre la valeur économisée, et non la réussite de l'objectif.
return  RunScenario();
 object? RunScenario()
{
    var applied = UO.moveTurnCost(14);
    UO.Print("Applied: " + Convert.ToString(applied));
    return null;
}

3. Appliquer à une section du script - classe de script

Paramètres et déroulement de l’exécution :

  • précédent stocke le paramètre initial ; NewMoveXY est limité à 3000 ms.
  • La dernière commande restaure le réglage après le retour du mouvement normal.
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.moveTurnCost();
        UO.moveTurnCost(14);
        var ok = UO.NewMoveXY(UO.GetX() + 2, UO.GetY(), true, 0, false, 0, 3000);
        UO.moveTurnCost(previous);
        UO.Print(Convert.ToString(ok));
        return null;
    }
}

Implémentation de la commande

C# distingue les majuscules. Utilisez le nom UO exact. Comparez les indicateurs numériques à 0 ; utilisez bool seulement si la signature renvoie bool.

UO.moveTurnCost() — UO.moveTurnCost()

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 "moveturncost": if (arguments.Length > 0) state.MoveTurnCost = Math.Max(0, Arg(0)); return new InjectionValue(state.MoveTurnCost);

UO.moveTurnCost(value) — UO.moveTurnCost(Any)

Paramètres: value (Any)

Résultat: dynamic / Any.

Pendant un appel:

Code interne de l’implémentation ; ce n’est pas un script autonome.

case "moveturncost": if (arguments.Length > 0) state.MoveTurnCost = Math.Max(0, Arg(0)); return new InjectionValue(state.MoveTurnCost);

UO.LimitMove — Limite de distance du déplacement. UO.LimitMove limite la distance à la destination : 2000 par défaut, zéro sans limite. Les limites cachées de 4096 pas/nœuds et 10000 nœuds sont supprimées. Le travail se déroule par tranches interruptibles. GetPathArray respecte le seuil d’endurance moveThroughNPC et moveOpenDoor.

ClassicUO — Bad Newbie & C# Scripts IDE

ClassicUO — Bad Newbie & C# Scripts IDE

Clone this wiki locally