FR UO Topic client ui

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

Client UI

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

Affichez les messages, les fenêtres de service, affichez les objets et ouvrez IDE. Ces étapes ne remplacent pas l'envoi de la parole au serveur.

Sections

Sujet	Commandes et explications
Print	UO.Print
ClientPrint	UO.ClientPrint
Info Window	UO.FillInfoWindow · UO.ClearInfoWindow · UO.FillNewWindow
Text Window	UO.TextOpen · UO.TextPrint · UO.TextClear · UO.TextClose
Des gommes simples	UO.CloseSimpleGump
Close UI Window	UO.CloseClientUIWindow
Circle Transparency	UO.CircleTrans
Show Z	UO.SetShowZ
Open IDE	UO.OpenIDE

Toutes les commandes du thème

Messages

UO.Print · UO.ClientPrint · UO.ClientPrintEx · UO.CharPrint · UO.ColorPrint · UO.ConsolePrint · UO.ServerPrint · UO.SetSilentMode · UO.ConColor · UO.FontColor

Fenêtres

UO.ClearInfoWindow · UO.FillInfoWindow · UO.FillNewWindow · UO.TextOpen · UO.TextClear · UO.TextClose · UO.TextPrint · UO.CloseSimpleGump · UO.CloseClientUIWindow · UO.ShowJournal · UO.OpenIDE · UO.HelpRequest · UO.ActivateHandle · UO.CloseHandle · UO.Snap

Affichage des objets

UO.Hide · UO.ClientHide · UO.ClientMarkChar · UO.CircleTrans · UO.SetShowZ · UO.Morph

Chiffres

UO.AddFigure · UO.UpdateFigure · UO.RemoveFigure · UO.ClearFigures

Exemples sur le sujet

Chaque carte de commande possède plusieurs scénarios indépendants : code direct, fonctions et classes. Vous trouverez ci-dessous une sélection de courts scénarios ; des restrictions et une analyse complète sont à prévoir.

UO.Print

Paramètres, résultat et tous les scénarios

var processed = 12;
UO.Print("Processed item entries: " + Convert.ToString(processed), 0x0044);

UO.FillInfoWindow

Paramètres, résultat et tous les scénarios

UO.FillInfoWindow("Status ready");

Référence complète des commandes

---

UO.ActivateHandle

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

Signatures C#

void UO.ActivateHandle();

Demande à Windows/SDL d'amener la fenêtre client actuelle au premier plan. Il n’y a ni arguments ni résultats. Il s'agit d'une commande de fenêtre, et non d'un élément, d'une compétence ou d'une application cible ; la mise au point réelle dépend du système de fenêtres.

Paramètres

Il n'y a pas de paramètres.

Valeur de retour

void. L'appel demande uniquement l'activation de la fenêtre ; il ne reconnaît pas que le système de fenêtrage l'a mis au premier plan.

Comportement

• Le client ouvre la fenêtre d'affichage du jeu via SDL. La commande n'envoie pas de paquet de jeu et n'effectue pas d'action dans le monde. Une fenêtre réduite ou des limitations du système de fenêtres peuvent empêcher la mise au point réelle.
• RequireGameView nécessite Client.Game. Si la fenêtre graphique de ClassicUO n'est pas ouverte, le pont lance InvalidOperationException. SDL_RaiseWindow demande qu'une fenêtre existante soit levée ; La décision concernant la mise au point est laissée au système de fenêtres.

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

1. Demander que la fenêtre client soit mise au premier plan. - scénario direct

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

• Demander que la fenêtre client soit mise au premier plan.

UO.ActivateHandle();

2. Ne demandez pas le focus de la fenêtre avant de vous connecter au jeu. - fonction de script

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

• Ne demandez pas le focus de la fenêtre avant de vous connecter au jeu.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Connected()))
    {
        UO.ActivateHandle();
    }

    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. Enveloppez l’action de la fenêtre dans une procédure réutilisable. - cours de script

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

• Enveloppez l’action de la fenêtre dans une procédure réutilisable.
• Exécutez la demande via une procédure auxiliaire.

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()
    {
        RunAction();
        return null;
    }

    void RunAction()
    {
        UO.ActivateHandle();
    }
}

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

Paramètres: Aucun paramètre.

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.ActivateHandle.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.ActivateHandle: bridge.ActivateHandle().

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

public void ActivateHandle() => bridge.ActivateHandle();

---

UO.AddFigure

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

Signatures C#

dynamic UO.AddFigure(object? figure);

Ajoute une figure locale à la carte du monde ClassicUO et renvoie son identifiant. Le chiffre est stocké côté client, le serveur de jeu n'est pas averti.

Paramètres

Valeur de retour

int est le positif ID du chiffre ajouté. 0 est renvoyé si les données du chiffre sont incorrectes ou si la carte refuse de les ajouter. Transférez le ID reçu vers UO.UpdateFigure ou UO.RemoveFigure.

Comportement

• Crée une figure locale pour WorldMapGump. Les lignes, les ellipses, les rectangles, les flèches directionnelles et le texte sont pris en charge. Les coordonnées fcWorld suivent la transformation et l'échelle de la carte ; fcScreen sont mesurés par rapport à la fenêtre de la carte. Les formes de la facette sélectionnée s'affichent.

Format du tableau : [kind, coord, x1, y1, x2, y2, brushColor, brushStyle, color, worldNum, text]. kind : 0 ligne, 1 ellipse, 2 rectangle, 3 flèche directionnelle, 4 texte. coord : 0 world, 1 écran. color utilise l'ordre des octets Delphi TColor (0x00BBGGRR). Pour une flèche avec des coordonnées mondiales et x2=0,y2=0, le point de départ est le caractère actuel. Les historiques brushColor et brushStyle sont adoptés pour des raisons de compatibilité ; l'ombrage visuel ne garantit pas une correspondance complète avec Delphi.

La figure reste dans la collection client jusqu'à ce qu'elle soit supprimée/purgée ou que le processus se termine. Changer de facette masque uniquement les figures appartenant à une autre facette.

• Un minimum de champs 9 est accepté. Si worldNum manque, la carte actuelle est utilisée ; sans texte, une chaîne vide est prise. le type est limité à 0..4, coord - 0..1 ; d'autres significations donnent 0. Le négatif worldNum permet l'affichage sur n'importe quelle facette. Le compteur ID est incrémenté avant la vérification de SetYokoMapFigure, donc une pièce rejetée peut laisser un vide dans ID. Collecte WorldMapGump statique en cours ; les scripts réguliers d'un gestionnaire utilisent un état d'exécution persistant commun.
• brushColor et brushStyle sont enregistrés dans l'entrée, mais le moteur de rendu actuel ne les utilise pas. La ligne et le rectangle sont dessinés comme un contour ; l'ellipse est constituée de segments 32. La signature textuelle est dessinée uniquement pour kind=4 ; les autres types ne le produisent pas. color spécifie le contour au format COLORREF 0x00BBGGRR.

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

1. Contour rouge d'un rectangle sur la carte du jeu - script direct

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

• kind=2 dessine un contour rouge. Le champ de texte avec la valeur Area est enregistré, mais pour ce type, l'étiquette n'est pas dessinée ; le texte affiche kind=4.

dynamic[] fig = new dynamic[checked((int)(11) + 1)];
fig[0] = 2;
fig[1] = 0;
fig[2] = UO.GetX("self")-3;
fig[3] = UO.GetY("self")-3;
fig[4] = UO.GetX("self")+3;
fig[5] = UO.GetY("self")+3;
fig[6] = 0;
fig[7] = 1;
fig[8] = 255;
fig[9] = UO.WorldNum();
fig[10] = "Area";
var figureId = UO.AddFigure(fig);

2. Une flèche d'un personnage vers un point de la carte du jeu - une fonction de script

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

• Avec les coordonnées world et x2=0,y2=0 l'origine de la flèche est prise à partir de la position du personnage lorsqu'il est dessiné. le texte avec la valeur Est pour kind=3 n'est pas affiché.

return  RunScenario();
 object? RunScenario()
{
    dynamic[] dirFig = new dynamic[checked((int)(11) + 1)];
    dirFig[0] = 3;
    dirFig[1] = 0;
    dirFig[2] = UO.GetX("self") + 10;
    dirFig[3] = UO.GetY("self");
    dirFig[4] = 0;
    dirFig[5] = 0;
    dirFig[6] = 0;
    dirFig[7] = 1;
    dirFig[8] = 65280;
    dirFig[9] = UO.WorldNum();
    dirFig[10] = "East";
    var arrowId = UO.AddFigure(dirFig);
    return null;
}

3. Créez une ligne bleue entre deux points de la facette actuelle. - cours de script

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

• Créez une ligne bleue entre deux points de la facette actuelle.

return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        dynamic[] lineFig = new dynamic[checked((int)(11) + 1)];
        lineFig[0] = 0;
        lineFig[1] = 0;
        lineFig[2] = UO.GetX("self");
        lineFig[3] = UO.GetY("self");
        lineFig[4] = UO.GetX("self") + 8;
        lineFig[5] = UO.GetY("self");
        lineFig[6] = 0;
        lineFig[7] = 1;
        lineFig[8] = 16711680;
        lineFig[9] = UO.WorldNum();
        lineFig[10] = "";
        var lineId = UO.AddFigure(lineFig);
        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.AddFigure(figure) — UO.AddFigure(Any)

Paramètres: figure (Any)

Résultat: dynamic / Any.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::TryMapFigureArg: TryMapFigureArg(0, out int[] figure, out string figureText).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.SetMapFigure: bridge.SetMapFigure(id, figure[0], figure[1], figure[2], figure[3], figure[4], figure[5], figure[6], figure[7], figure[8], figure[9], figureText).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::SerializeMapFigure: SerializeMapFigure(figure, figureText).

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

case "addfigure":

                {

                    if (!TryMapFigureArg(0, out int[] figure, out string figureText))

                        return InjectionValue.Zero;

                    int id = state.NextMapFigureId++;

                    if (bridge.SetMapFigure(id, figure[0], figure[1], figure[2], figure[3], figure[4], figure[5], figure[6], figure[7], figure[8], figure[9], figureText) == 0)

                        return InjectionValue.Zero;

                    state.MapFigures[id] = SerializeMapFigure(figure, figureText);

                    return new InjectionValue(id);

                }

---

UO.CharPrint

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

Signatures C#

void UO.CharPrint(object? color, object? msg);
void UO.CharPrint(object? id, object? color, object? msg);

Crée une inscription visible uniquement par vous au-dessus de l'objet chargé : par exemple, une marque de la cible sélectionnée ou un avertissement au-dessus de votre personnage. Il ne s'agit pas du discours du personnage ni du message en bas de la fenêtre de jeu.

Paramètres

• id est la série de l'objet, pas graphic/type ou une coordonnée. UO.CharPrint sous forme de trois arguments comprend également self, lasttarget et les noms d'objets stockés. Pour SenderID dans UO.ClientPrintEx, utilisez un numéro, tel que UO.Hex2Int(UO.GetSerial("self")); les alias de chaîne n'y sont pas résolus en tant qu'objets.
• color est UO hue, pas RGB. Les bits 16 de poids faible du nombre sont pris ; 0x0044 en est un exemple. -1 devient 0xFFFF plutôt que de signifier "n'importe quelle couleur". La couleur ConColor n'est pas utilisée ici.

Valeur de retour

Un appel à une méthode avec un type de retour void est écrit sous la forme d'une instruction autonome C# ; le résultat ne peut pas être attribué ou vérifié. Le fait de remplir la déclaration ne constitue pas une confirmation de la part du serveur de jeu.

Comportement

• L'objet doit exister dans le monde chargé et ne pas être supprimé ; le texte vide ou la cible manquante ne sont pas dessinés. La commande ne télécharge pas l'objet depuis le serveur. Le serveur et les autres joueurs ne reçoivent pas ce message. Sans la fenêtre de jeu, l’inscription ne peut être vue dans le monde ; ce n'est pas un remplacement pour le syslog du gestionnaire.
• UO.CharPrint(color, msg) sélectionne son personnage. UO.CharPrint(id, color, msg) sélectionne l'objet spécifié. Les deux formulaires utilisent la police 3. UO.ClientPrintEx nécessite les quatre arguments dans l'ordre SenderID, Color, Font, Text.
• Le numéro de police est UO, et non la taille en points ou le nom de la police Windows. Le nombre est limité à la plage 0..255 ; La disponibilité d'une police spécifique dépend des fichiers du jeu. Dans l'exemple, 3 est le numéro de police normal.
• GetSerial renvoie une chaîne hexadécimale. Hex2Int le transforme en int avant de le comparer avec le nombre 0 ; la chaîne "0x00000000" ne peut pas être vérifiée comme le nombre 0.
• UO.Print · UO.CharPrint · UO.ClientPrintEx · UO.AddToSystemJournalEx

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.CharPrint");
UO.CharPrint(0x0044, "Ready");

1. UO.CharPrint - 1 - script direct

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

• La première forme CharPrint place Ready au-dessus de son caractère. ClientPrintEx le reçoit serial via UO.Hex2Int(UO.GetSerial("self")) et transmet explicitement la police à 3. L'inscription n'inclut aucun mode de jeu.
• GetSerial renvoie une chaîne hexadécimale. Hex2Int le transforme en int avant de le comparer avec le nombre 0 ; la chaîne "0x00000000" ne peut pas être vérifiée comme le nombre 0.

UO.CharPrint(0x0044, "Ready");

2. UO.CharPrint — 2 — fonction de script

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

• target — serial de la dernière cible. Zéro signifie qu’il n’y a personne à taguer dans cet exemple. Cible sélectionnée - signature locale uniquement : la cible n'est pas attaquée et la cible du serveur actif n'est pas remplie.
• GetSerial renvoie une chaîne hexadécimale. Hex2Int le transforme en int avant de le comparer avec le nombre 0 ; la chaîne "0x00000000" ne peut pas être vérifiée comme le nombre 0.

return  RunScenario();
 object? RunScenario()
{
    var target = UO.Hex2Int(UO.GetSerial("lasttarget"));
    if (Truth(target != 0))
    {
        UO.CharPrint(target, 0x0044, "Selected target");
    }

    return null;
}

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

3. UO.CharPrint - 3 - classe de scénario

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

• ShowWeightWarning est déclaré intégralement ci-dessous. Elle compare le poids à une limite positive connue et n'écrit sur son personnage qu'en cas de surcharge ; ne jette rien. Convert.ToString transforme le poids en texte.
• GetSerial renvoie une chaîne hexadécimale. Hex2Int le transforme en int avant de le comparer avec le nombre 0 ; la chaîne "0x00000000" ne peut pas être vérifiée comme le nombre 0.

return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        ShowWeightWarning(UO.Weight(), UO.MaxWeight());
        return null;
    }

    void ShowWeightWarning(dynamic weight, dynamic maximum)
    {
        if (Truth(maximum > 0) && Truth(weight >= maximum))
        {
            UO.CharPrint(UO.Hex2Int(UO.GetSerial("self")), 0x0044, "Too heavy: " + Convert.ToString(weight));
        }
    }

    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.CharPrint(color, msg) — UO.CharPrint(Integer,String)

Paramètres: color (Integer/String), msg (String)

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.CharPrint.
• InjectionScript.Runtime.InjectionApiUO.CharPrint: CharPrint(bridge.Self, color, msg).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self: bridge.Self.

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

public void CharPrint(int color, string msg) => CharPrint(bridge.Self, color, msg);

UO.CharPrint(color, msg) — UO.CharPrint(String,String)

Paramètres: color (Integer/String), msg (String)

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.CharPrint.
• InjectionScript.Runtime.InjectionApiUO.CharPrint: CharPrint(bridge.Self, NumberConversions.ToInt(color), msg).
• InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(color).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self: bridge.Self.

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

public void CharPrint(string color, string msg) => CharPrint(bridge.Self, NumberConversions.ToInt(color), msg);

UO.CharPrint(id, color, msg) — UO.CharPrint(Any,Any,Any)

Paramètres: id (Any/Integer), color (Any/Integer), msg (Any/String)

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.CharPrint.
• InjectionScript.Runtime.InjectionApiUO.CharPrint: CharPrint(GetObject(id), NumberConversions.ToInt(color), (string)msg).
• InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(id).
• InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(color).

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

public void CharPrint(InjectionValue id, InjectionValue color, InjectionValue msg) 

            => CharPrint(GetObject(id), NumberConversions.ToInt(color), (string)msg);

UO.CharPrint(id, color, msg) — UO.CharPrint(Integer,Integer,String)

Paramètres: id (Any/Integer), color (Any/Integer), msg (Any/String)

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.CharPrint.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CharPrint: bridge.CharPrint(id, color, msg).

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

public void CharPrint(int id, int color, string msg) => bridge.CharPrint(id, color, msg);

---

UO.CircleTrans

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

Signatures C#

int UO.CircleTrans();
void UO.CircleTrans(object? enabled);

Lit ou modifie le paramètre de cercle de transparence du profil actif.

Paramètres

• enabled - int : 0 est désactivé, toute valeur non nulle est activée. Sans argument, le paramètre est en lecture seule.

Valeur de retour

Sans argument int 1/0; le formulaire avec un argument renvoie null.

Comportement

• La lecture en l'absence de profil donne 0. Une entrée sans profil imprime une erreur ; s'il existe un profil, modifie UseCircleOfTransparency et enregistre le profil. Il s'agit d'une personnalisation visuelle du client.

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

1. Paramètres de lecture - script direct

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

• La lecture ne change pas le profil.

var enabled = UO.CircleTrans();
UO.Print(Convert.ToString(enabled));

2. Activer la transparence - Fonction de script

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

• L'enregistrement maintient le cercle de transparence activé.

return  RunScenario();
 object? RunScenario()
{
    UO.CircleTrans(1);
    return null;
}

3. Restaurer la valeur précédente - Classe de script

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

• Le drapeau enregistré est restauré après un changement temporaire de réglage.

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.CircleTrans();
        UO.CircleTrans(0);
        UO.CircleTrans(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.CircleTrans() — UO.CircleTrans()

Paramètres: Aucun paramètre.

Résultat: int / Integer.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.CircleTrans.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CircleTrans: bridge.CircleTrans().

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

public int CircleTrans() => bridge.CircleTrans();

UO.CircleTrans(enabled) — UO.CircleTrans(Integer)

Paramètres: enabled (Integer)

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.CircleTrans.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CircleTrans: bridge.CircleTrans(enabled).

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

public void CircleTrans(int enabled) => bridge.CircleTrans(enabled);

---

UO.ClearFigures

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

Signatures C#

void UO.ClearFigures();

Supprime toutes les formes de carte personnalisées et leurs entrées d'exécution.

Paramètres

Il n'y a pas de paramètres.

Valeur de retour

void - aucune valeur de retour.

Comportement

• Efface WorldMapGump.ClearYokoMapFigures et state.MapFigures. La carte de base et UserStatics ne sont pas modifiés.
• ClearYokoMapFigures efface la collection statique de WorldMapGump en cours, puis la commande efface MapFigures de son état d'exécution. Cette étendue de nettoyage est déterminée par la collection globale de clients, et pas seulement par le nom du script appelant.
• Les étiquettes de carte personnalisées habituelles (userMarkers.usr) sont conservées.

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

1. État clair - script direct

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

• Supprime toutes les formes de carte personnalisées et leurs entrées d'exécution.

UO.ClearFigures();

2. Effacer après l'installation - fonction de script

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

• Créez une forme locale pour la carte actuelle, puis supprimez toutes les formes personnalisées.

return  RunScenario();
 object? RunScenario()
{
    dynamic[] figure = new dynamic[checked((int)(9) + 1)];
    figure[0] = 0;
    figure[1] = 0;
    figure[2] = UO.GetX();
    figure[3] = UO.GetY();
    figure[4] = figure[2] + 1;
    figure[5] = figure[3] + 1;
    figure[6] = 0;
    figure[7] = 0;
    figure[8] = 0;
    figure[9] = UO.WorldNum();
    var figureId = UO.AddFigure(figure);
    UO.ClearFigures();
    return null;
}

3. Re-Purge - Classe de script

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

• Effacer un ensemble vide est acceptable et ne crée pas de nouveau paramètre.

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

Paramètres: Aucun paramètre.

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.ClearMapFigures: bridge.ClearMapFigures().

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

case "clearfigures":

                    bridge.ClearMapFigures();

                    state.MapFigures.Clear();

                    return InjectionValue.Unit;

---

UO.ClearInfoWindow

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

Signatures C#

void UO.ClearInfoWindow();

Efface les lignes de la fenêtre de texte du client.

Paramètres

Il n'y a pas de paramètres.

Valeur de retour

void - aucune valeur de retour.

Comportement

• TextClear efface le tampon ; si la fenêtre était ouverte, la met à jour avec un contenu vide. La fenêtre ne se ferme pas nécessairement.

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

1. État clair - script direct

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

• Efface les lignes de la fenêtre de texte du client.

UO.ClearInfoWindow();

2. Effacer après l'installation - fonction de script

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

• Effacez une ligne de fenêtre de texte précédemment ajoutée.

return  RunScenario();
 object? RunScenario()
{
    UO.FillInfoWindow("status");
    UO.ClearInfoWindow();
    return null;
}

3. Re-Purge - Classe de script

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

• Effacer un ensemble vide est acceptable et ne crée pas de nouveau paramètre.

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

Paramètres: Aucun paramètre.

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.TextClear: bridge.TextClear().

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

case "clearinfowindow": bridge.TextClear(); return InjectionValue.Unit;

---

UO.ClientHide

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

Signatures C#

dynamic UO.ClientHide(object? objID);

Masque serial un objet chargé ou un autre personnage dans l'affichage ClassicUO uniquement, y compris les conteneurs, les poupées en papier et les objets équipés.

Paramètres

• objID — Série de l'objet chargé spécifique : int ou chaîne hexadécimale/décimale. Ce n'est pas graphic/type. Pour un nom enregistré, utilisez GetSerial(nom). Le paramètre est obligatoire ; la vue n'apparaît pas.

Valeur de retour

int 1 après avoir transmis la commande du pont. Le résultat historique ne confirme pas la présence de l'objet : même pour un pont serial ou self inconnu génère un échec, et le runtime renvoie 1. N'utilisez pas cette valeur comme test de masquage réussi. Les métadonnées de compatibilité affichent object?.

Comportement

• Exactement un argument est requis. Pour sélectionner avec la souris, utilisez UO.Hide().
• Hide(serial) agit immédiatement sur un objet chargé connu. Passez serial d'une pile/un élément spécifique plutôt que graphic/type. La pile sélectionnée est entièrement masquée, quel que soit le montant.
• L'article reste dans le conteneur : la quantité, le propriétaire, le contenu et l'état du serveur ne changent pas. FindType/GetContent peuvent toujours le trouver. Le masquage n'est pas un filtre de recherche, un report, une suppression, une compétence de masquage ou une invisibilité côté serveur.
• Le conteneur normal, la fenêtre d'échange et la grille de butin ne dessinent pas l'objet caché et n'acceptent pas les clics/glisser dessus. L'indicateur persiste lorsque la fenêtre est reconstruite et rouverte alors que le même objet chargé est en cours d'utilisation.
• L'objet équipé disparaît de la poupée en papier, de la petite fente et de l'image du personnage. Il reste équipé : le layer, l'armure et l'état sur le serveur ne changent pas. La robe cachée ne chevauche plus les sous-vêtements. L'image du personnage dans le gestionnaire est mise à jour en utilisant le même indicateur ; la liste des équipements actuels reste disponible.
• Hide ne cache pas son propre caractère, son terrain et sa statique. Le serial inexistant donne un message. Masquer le sac lui-même ne ferme pas la fenêtre de contenu déjà ouverte et ne masque pas automatiquement chaque élément inclus.
• Il n'y a pas de commande Afficher distincte dans le API actuel. Le masquage appartient à l'instance d'objet chargée : la supprimer du monde client et la charger à nouveau (par exemple, lors de la reconnexion) réinitialise l'indicateur. Le simple fait de fermer/ouvrir un coffre ne constitue pas un moyen garanti de retourner un article.

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

1. Masquer l'élément par ID connu - script direct

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

• ObjID est un élément spécifique, pas son type. Il disparaît de l'écran et reste dans son contenant.

var item = 0x40001234;
if (Truth(UO.Exists(item)))
{
    UO.ClientHide(item);
}

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

2. Masquer la pile trouvée - Fonction de script

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

• FindType recherche graphic 0x0EED de n'importe quelle couleur dans backpack. Le serial renvoyé est transmis à ClientHide ; la pile entière est entièrement masquée.

return  RunScenario();
 object? RunScenario()
{
    var item = UO.FindType(0x0EED, -1, "backpack");
    if (Truth(item != ""))
    {
        UO.ClientHide(item);
        UO.Print("Amount is still: " + Convert.ToString(UO.GetQuantity(item)));
    }

    return null;
}

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

3. Utiliser un objet nommé - Classe de script

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

• GetSerial résout le nom de décoration précédemment enregistré. L'article doit d'abord être chargé, par exemple en ouvrant son conteneur.

return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var item = UO.GetSerial("decoration");
        if (Truth(UO.Exists(item)) && Truth(item != UO.GetSerial("self")))
        {
            UO.ClientHide(item);
        }

        return null;
    }

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

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

Paramètres: objID (Any)

Résultat: dynamic / Any.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.ClientHide: bridge.ClientHide(Arg(0)).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).

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

case "clienthide": bridge.ClientHide(Arg(0)); return InjectionValue.True;

---

UO.ClientMarkChar

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

Signatures C#

void UO.ClientMarkChar(object? actionIndex, object? id);

Met à jour les étiquettes client LastTarget et/ou LastAttack.

Paramètres

• actionIndex - int : 1 - LastTarget ; 2 - LastAttack ; 3 - les deux. D'autres valeurs impriment une erreur.
• id — Numéro de série de l'objet ou nom pris en charge de l'objet self/backpack/lasttarget/saved ; les chaînes numériques et les chaînes 0x sont résolues par l'exécution.

Valeur de retour

void - aucune valeur de retour.

Comportement

• ClientMarkChar modifie les cibles enregistrées sans envoyer d'attaque ni répondre à la cible du serveur. Les commandes suivantes peuvent utiliser la nouvelle étiquette.

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.ClientMarkChar");
UO.ClientMarkChar(1, "self");

1. Mise à jour LastTarget - script direct

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

• La cible enregistrée devient votre propre personnage.

UO.ClientMarkChar(1,"self");

2. Mettre à jour les deux étiquettes - fonction de script

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

• Cette dernière cible est utilisée pour les deux balises client.

return  RunScenario();
 object? RunScenario()
{
    var target = UO.LastTarget();
    if (Truth(UO.Exists(target)))
    {
        UO.ClientMarkChar(3, target);
    }

    return null;
}

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

3. Action incorrecte - Classe de script

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

• Zéro ne fait pas partie de l'ensemble d'actions et génère un message d'erreur.

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.ClientMarkChar(0, "self");
        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.ClientMarkChar(actionIndex, id) — UO.ClientMarkChar(Any,Any)

Paramètres: actionIndex (Any), id (Any)

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.ClientMarkChar.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.ClientMarkChar: bridge.ClientMarkChar(NumberConversions.ToInt(actionIndex), GetObject(id)).
• InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(actionIndex).
• InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(id).

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

public void ClientMarkChar(InjectionValue actionIndex, InjectionValue id)

            => bridge.ClientMarkChar(NumberConversions.ToInt(actionIndex), GetObject(id));

---

UO.ClientPrint

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

Signatures C#

void UO.ClientPrint(object? text);

Affiche un message local sur la progression du script ou la condition d'arrêt. Vous le voyez, pas les autres joueurs.

Paramètres

Valeur de retour

Un appel à une méthode avec un type de retour void est écrit sous la forme d'une instruction autonome C# ; le résultat ne peut pas être attribué ou vérifié. Le fait de remplir la déclaration ne constitue pas une confirmation de la part du serveur de jeu.

Comportement

• Le message va dans la zone inférieure gauche de la fenêtre de jeu et dans le journal local. Une copie est disponible en sortie IDE. Dans le journal général du manager, activez le filtre des messages du script : l'entrée est disponible sans la fenêtre de jeu. Le filtre de messages du système serveur ne sélectionne pas ces enregistrements. Le paquet vocal réseau n'est pas envoyé. Pour l'inscription au dessus de la tête il y a UO.CharPrint.
• UO.Print ajoute une nouvelle entrée au journal des messages du jeu : lisez ou enregistrez d'abord la chaîne/le résultat de recherche souhaité, puis enregistrez le message de diagnostic. Dans une boucle rapide, enregistrez les messages lorsque des changements se produisent plutôt qu'à chaque itération.
• La couleur des messages système de ce runtime de script est utilisée : initialement 0x0440, modifiée UO.ConColor. Il s'agit d'une entrée locale ; le nom de la commande ne signifie pas son envoi au serveur.
• UO.Print · UO.CharPrint · UO.Say · UO.ConColor

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 est une instruction séparée sans valeur de retour (void). Le texte du message figure directement dans l’appel.

UO.ClientPrint("Hello from C#");

1. Bref rapport - script direct

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

• Processed=12 — nombre de démonstration d'éléments déjà traités. Convert.ToString le transforme en chaîne. Cet exemple ne rapporte qu'un nombre ; il ne transfère pas les objets eux-mêmes.

var processed = 12;
UO.ClientPrint("Processed item entries: " + Convert.ToString(processed));

2. Avertissement de surcharge - Fonction de script

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

• Le poids et le maximum du personnage sont lus. Un maximum nul/inconnu n’est pas considéré comme une surcharge. Si poids >= maximum, une ligne est imprimée et Main se termine ; les objets ne sont pas jetés.

return  RunScenario();
 object? RunScenario()
{
    var weight = UO.Weight();
    var maximum = UO.MaxWeight();
    if (Truth(maximum > 0) && Truth(weight >= maximum))
    {
        UO.ClientPrint("Too heavy: " + Convert.ToString(weight) + "/" + Convert.ToString(maximum));
        return null;
    }

    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. Signaler les modifications de poids uniquement - Classe de script

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

• Main se souvient du poids, attend 1000 millisecondes et appelle le ReportWeight entièrement déclaré. L'assistant n'imprime que si le poids a changé et renvoie le nouveau poids pour le prochain contrôle. Il ne crée pas lui-même une boucle infinie.

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.Weight();
        UO.Wait(1000);
        previous = ReportWeight(previous, UO.Weight());
        return null;
    }

    dynamic ReportWeight(dynamic previous, dynamic current)
    {
        if (Truth(previous != current))
        {
            UO.ClientPrint("Weight changed: " + Convert.ToString(current));
        }

        return current;
    }

    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.ClientPrint(text) — UO.ClientPrint(Any)

Paramètres: text (Any)

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• InjectionScript.Runtime.InjectionApiUO.SystemMessage: SystemMessage(Text(0)).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Text: Text(0).

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

case "addtojournal":

                case "addtosystemjournal":

                case "clientprint":

                    SystemMessage(Text(0)); return InjectionValue.Unit;

---

UO.ClientPrintEx

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

Signatures C#

void UO.ClientPrintEx(object? senderID, object? color, object? font, object? text);

Crée une inscription visible uniquement par vous au-dessus de l'objet chargé : par exemple, une marque de la cible sélectionnée ou un avertissement au-dessus de votre personnage. Il ne s'agit pas du discours du personnage ni du message en bas de la fenêtre de jeu.

Paramètres

• senderID est la série de l'objet, pas graphic/type ou une coordonnée. UO.CharPrint sous forme de trois arguments comprend également self, lasttarget et les noms d'objets stockés. Pour SenderID dans UO.ClientPrintEx, utilisez un numéro, tel que UO.Hex2Int(UO.GetSerial("self")); les alias de chaîne n'y sont pas résolus en tant qu'objets.
• color est UO hue, pas RGB. Les bits 16 de poids faible du nombre sont pris ; 0x0044 en est un exemple. -1 devient 0xFFFF plutôt que de signifier "n'importe quelle couleur". La couleur ConColor n'est pas utilisée ici.
• font — Numéro de police UO, pas la taille en points ou le nom de la police Windows. Le nombre est limité à la plage 0..255 ; La disponibilité d'une police spécifique dépend des fichiers du jeu. Dans l'exemple, 3 est le numéro de police normal.

Valeur de retour

Un appel à une méthode avec un type de retour void est écrit sous la forme d'une instruction autonome C# ; le résultat ne peut pas être attribué ou vérifié. Le fait de remplir la déclaration ne constitue pas une confirmation de la part du serveur de jeu.

Comportement

• L'objet doit exister dans le monde chargé et ne pas être supprimé ; le texte vide ou la cible manquante ne sont pas dessinés. La commande ne télécharge pas l'objet depuis le serveur. Le serveur et les autres joueurs ne reçoivent pas ce message. Sans la fenêtre de jeu, l’inscription ne peut être vue dans le monde ; ce n'est pas un remplacement pour le syslog du gestionnaire.
• UO.CharPrint(color, msg) sélectionne son personnage. UO.CharPrint(id, color, msg) sélectionne l'objet spécifié. Les deux formulaires utilisent la police 3. UO.ClientPrintEx nécessite les quatre arguments dans l'ordre SenderID, Color, Font, Text.
• Le numéro de police est UO, et non la taille en points ou le nom de la police Windows. Le nombre est limité à la plage 0..255 ; La disponibilité d'une police spécifique dépend des fichiers du jeu. Dans l'exemple, 3 est le numéro de police normal.
• GetSerial renvoie une chaîne hexadécimale. Hex2Int le transforme en int avant de le comparer avec le nombre 0 ; la chaîne "0x00000000" ne peut pas être vérifiée comme le nombre 0.
• UO.Print · UO.CharPrint · UO.ClientPrintEx · UO.AddToSystemJournalEx

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.ClientPrintEx");
UO.ClientPrintEx(UO.Hex2Int(UO.GetSerial("self")), 0x0044, 3, "Ready");

1. UO.ClientPrintEx - 1 - script direct

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

• La première forme CharPrint place Ready au-dessus de son caractère. ClientPrintEx le reçoit serial via UO.Hex2Int(UO.GetSerial("self")) et transmet explicitement la police à 3. L'inscription n'inclut aucun mode de jeu.
• GetSerial renvoie une chaîne hexadécimale. Hex2Int le transforme en int avant de le comparer avec le nombre 0 ; la chaîne "0x00000000" ne peut pas être vérifiée comme le nombre 0.

UO.ClientPrintEx(UO.Hex2Int(UO.GetSerial("self")), 0x0044, 3, "Ready");

2. UO.ClientPrintEx — 2 — fonction de script

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

• target — serial de la dernière cible. Zéro signifie qu’il n’y a personne à taguer dans cet exemple. Cible sélectionnée - signature locale uniquement : la cible n'est pas attaquée et la cible du serveur actif n'est pas remplie.
• GetSerial renvoie une chaîne hexadécimale. Hex2Int le transforme en int avant de le comparer avec le nombre 0 ; la chaîne "0x00000000" ne peut pas être vérifiée comme le nombre 0.

return  RunScenario();
 object? RunScenario()
{
    var target = UO.Hex2Int(UO.GetSerial("lasttarget"));
    if (Truth(target != 0))
    {
        UO.ClientPrintEx(target, 0x0044, 3, "Selected target");
    }

    return null;
}

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

3. UO.ClientPrintEx - 3 - classe de scénario

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

• ShowWeightWarning est déclaré intégralement ci-dessous. Elle compare le poids à une limite positive connue et n'écrit sur son personnage qu'en cas de surcharge ; ne jette rien. Convert.ToString transforme le poids en texte.
• GetSerial renvoie une chaîne hexadécimale. Hex2Int le transforme en int avant de le comparer avec le nombre 0 ; la chaîne "0x00000000" ne peut pas être vérifiée comme le nombre 0.

return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        ShowWeightWarning(UO.Weight(), UO.MaxWeight());
        return null;
    }

    void ShowWeightWarning(dynamic weight, dynamic maximum)
    {
        if (Truth(maximum > 0) && Truth(weight >= maximum))
        {
            UO.ClientPrintEx(UO.Hex2Int(UO.GetSerial("self")), 0x0044, 3, "Too heavy: " + Convert.ToString(weight));
        }
    }

    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.ClientPrintEx(senderID, color, font, text) — UO.ClientPrintEx(Any,Any,Any,Any)

Paramètres: senderID (Any), color (Any), font (Any), text (Any)

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CharPrintEx: bridge.CharPrintEx(Arg(0), Arg(1), Arg(2), Text(3)).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Text: Text(3).

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

case "clientprintex":

                    bridge.CharPrintEx(Arg(0), Arg(1), Arg(2), Text(3)); return InjectionValue.Unit;

---

UO.CloseClientUIWindow

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

Signatures C#

void UO.CloseClientUIWindow(object? uiWindowType, object? id);

Ferme la fenêtre client locale du type spécifié pour un objet spécifique. Par exemple, vous pouvez supprimer la poupée de papier du personnage, son statut ou la fenêtre du sac à dos. La commande ne ferme pas le client du jeu et ne répond pas aux boutons Gump du serveur.

Paramètres

• uiWindowType — Code de fenêtre numérique obligatoire : 0 — paperdoll (équipement), 1 — statut du personnage, 2 — profil, 3 — conteneur. Il s'agit d'une liste distincte de quatre codes, pas du corps graphic/type ni du gump du serveur ID. Les autres numéros ne trouvent pas la fenêtre.
• id — Série de l'objet auquel appartient la fenêtre : caractère self/serial pour les types 0..2, conteneur backpack/serial pour le type 3. Accepte un nombre, une chaîne hexadécimale ou un alias d'objet résoluble. Ce n'est pas le numéro de fenêtre dans la liste InfoGumps. Un alias d'objet inconnu est converti en 0.

Valeur de retour

void - aucune valeur. L'appel est écrit sur une ligne séparée, sans var result = et sans if UO.CloseClientUIWindow(...). S’il n’y a pas de fenêtre ouverte appropriée, rien ne se passe ; la commande ne renvoie pas true/false.

Comportement

• Les deux paramètres sont obligatoires. La classe window et LocalSerial sont comparées. Appeler avec (3, self) ne signifie pas sac à dos : le sac à dos nécessite backpack.
• Le contournement affecte les fenêtres ouvertes et non encore détruites de ce type/serial ; toutes les fenêtres correspondantes sont fermées sur le fil de jeu. Les fenêtres restantes restent ouvertes.
• L'interface se ferme, les éléments ne sont pas supprimés du conteneur et le personnage ne disparaît pas du monde. On peut le répéter sans risque : si la fenêtre est déjà fermée, il n'y a pas de correspondance.
• Pour les boîtes de dialogue côté serveur, étudiez UO.CloseSimpleGump et UO.NumGumpButton ; les codes 0..3 de cette commande ne s'y appliquent pas.

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

1. Retirez votre poupée de papier - script direct

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

• Seule la fenêtre de l'équipement de votre personnage se ferme ; son statut, son profil et son sac à dos restent des fenêtres séparées.

UO.CloseClientUIWindow(0, "self");

2. Fermez la fenêtre du sac à dos après avoir travaillé avec des objets - fonction de script

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

• Si le sac à dos n’a pas été ouvert, l’action ne changera rien. Cette commande ne déplace pas les éléments et ne renvoie aucun résultat.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Connected()) && Truth(UO.Exists("backpack")))
    {
        UO.CloseClientUIWindow(3, "backpack");
    }

    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. Supprimer le statut et le profil du personnage sélectionné - classe de scénario

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

• 1 - statut, 2 - profil. L'identifiant est serial du mobile sélectionné. ASC(text,0) analyse ici la chaîne serial en un nombre avec un 0 de rechange. La procédure utilisateur ne promet rien sur la présence d'une fenêtre ; les deux appels ont Unit.

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 selected = Asc(UO.GetSerial("lasttarget"), 0);
        CloseMobilePanels(selected);
        return null;
    }

    void CloseMobilePanels(dynamic id)
    {
        if (Truth(id == 0) || !(Truth(UO.Exists(id))))
        {
            return;
        }

        UO.CloseClientUIWindow(1, id);
        UO.CloseClientUIWindow(2, id);
    }

    int Asc(object? value, int fallback = 0)
    {
        string text = Convert.ToString(value) ?? "";
        if (text.StartsWith("0x", StringComparison.OrdinalIgnoreCase))
            return int.TryParse(text[2..], System.Globalization.NumberStyles.HexNumber, System.Globalization.CultureInfo.InvariantCulture, out int hex) ? hex : fallback;
        return int.TryParse(text, out int number) ? number : fallback;
    }

    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.CloseClientUIWindow(uiWindowType, id) — UO.CloseClientUIWindow(Any,Any)

Paramètres: uiWindowType (Any), id (Any)

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CloseClientWindow: bridge.CloseClientWindow(Arg(0), Arg(1)).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).

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

case "closeclientuiwindow": bridge.CloseClientWindow(Arg(0), Arg(1)); return InjectionValue.Unit;

---

UO.CloseHandle

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

Signatures C#

void UO.CloseHandle();

Demande à l’application client actuelle de quitter via Client.Game.Exit.

Paramètres

Il n'y a pas de paramètres.

Valeur de retour

void - aucune valeur de retour.

Comportement

• CloseUO est envoyé vers le même pont.CloseHandle. La sortie est exécutée sur le thread de jeu ; si Client.Game est manquant, il n'y a aucune action. La commande n'est pas un arrêt d'un Gump séparé.

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

1. Terminer le client - Script direct

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

• L'appel demande la résiliation de l'application client.

UO.CloseHandle();

2. Condition de terminaison explicite - fonction de script

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

• L'exemple montre une condition contrôlée ; la valeur 0 maintient le client ouvert.

return  RunScenario();
 object? RunScenario()
{
    var finishClient = 0;
    if (Truth(finishClient))
    {
        UO.CloseHandle();
    }

    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. Procédure d'achèvement - Classe de script

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

• Un assistant entièrement déclaré permet une activation explicite de la sortie.

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()
    {
        FinishClient(0);
        return null;
    }

    void FinishClient(dynamic enabled)
    {
        if (Truth(enabled))
        {
            UO.CloseHandle();
        }
    }

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

Paramètres: Aucun paramètre.

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.CloseHandle.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CloseHandle: bridge.CloseHandle().

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

public void CloseHandle() => bridge.CloseHandle();

---

UO.CloseSimpleGump

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

Signatures C#

void UO.CloseSimpleGump(object? gumpIndex);

Ferme localement un serveur Gump qui peut être fermé par un index strict.

Paramètres

• gumpIndex — Obligatoire int — index du serveur Gump actif, de 0 à GetGumpsCount()-1. This is not GumpID/serial. Les nombres négatifs et les index en dehors de la liste ne sont pas valides. L'ouverture, la fermeture et la réorganisation des fenêtres peuvent modifier l'index ; check GetGumpID/GetGumpSerial before acting.

Valeur de retour

void - ne renvoie rien. Le résultat ne doit pas être interprété comme une confirmation du serveur ou de bool.

Comportement

• Fonctionne avec les Gumps de serveur actifs. Le sac à dos, la carte, les paramètres et autres fenêtres locales ne sont pas inclus dans cette liste. Un appel lit les données dans le fil de jeu ; différents appels peuvent voir différents états de la liste.
• Un index invalide et NoClose ne changent rien. La commande n'envoie pas la réponse du bouton au serveur. Pour cette réponse, utilisez SendGumpSelect.
• La fermeture modifie la liste et les index. Pour fermer en masse, parcourez la liste du dernier index au premier.

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

1. Fermez la première fenêtre - script direct

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

• 0 est un index, pas ID. Si la fenêtre interdit la fermeture, elle reste ouverte.

UO.CloseSimpleGump(0);

2. Fermez toutes les fenêtres activées - fonction de script

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

• Le parcours inversé réduit l’impact des changements d’index après la clôture. Lorsque vous ouvrez de nouvelles fenêtres en parallèle, vérifiez à nouveau la liste.

return  RunScenario();
 object? RunScenario()
{
    var i = UO.GetGumpsCount() - 1;
    while (Truth(i >= 0))
    {
        UO.CloseSimpleGump(i);
        i = i - 1;
    }

    return null;
}

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

3. Enregistrer les informations avant de fermer - classe de script

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

• info[1] - GumpID enregistré. L'action ne renvoie rien, le résultat n'est donc pas affecté à la variable.

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 info = UO.GetGumpInfo(0);
        if (Truth(ArrayLength(info) == 5))
        {
            UO.CloseSimpleGump(0);
            UO.Print(Hex(info[1]));
        }

        return null;
    }

    int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
    string Hex(object? value) => Convert.ToInt64(value).ToString("X");
    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.CloseSimpleGump(gumpIndex) — UO.CloseSimpleGump(Any)

Paramètres: gumpIndex (Any)

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CloseSimpleGump: bridge.CloseSimpleGump(Arg(0)).

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

case "closesimplegump":

                    if (bridge is IApiGumpAccess gumpAccess) gumpAccess.CloseGumpAtIndex(Arg(0));

                    else bridge.CloseSimpleGump(Arg(0));

                    return InjectionValue.Unit;

---

UO.ColorPrint

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

Signatures C#

void UO.ColorPrint(object? color, object? msg);

Affiche un message local sur la progression du script ou la condition d'arrêt. Vous le voyez, pas les autres joueurs.

Paramètres

• color - UO hue, pas RGB. Nombre ou chaîne hexadécimale ; le pont utilise les bits faibles 16. A ne pas confondre avec graphic/type. 0x0044 dans l'exemple est le hue sélectionné. Sans couleur, hue 0x03B2 est utilisé. UO.Print(text, color) accepte le texte en premier ; UO.ColorPrint(color, text) – la couleur d'abord.

Valeur de retour

Un appel à une méthode avec un type de retour void est écrit sous la forme d'une instruction autonome C# ; le résultat ne peut pas être attribué ou vérifié. Le fait de remplir la déclaration ne constitue pas une confirmation de la part du serveur de jeu.

Comportement

• Le message va dans la zone inférieure gauche de la fenêtre de jeu et dans le journal local. Une copie est disponible en sortie IDE. Dans le journal général du manager, activez le filtre des messages du script : l'entrée est disponible sans la fenêtre de jeu. Le filtre de messages du système serveur ne sélectionne pas ces enregistrements. Le paquet vocal réseau n'est pas envoyé. Pour l'inscription au dessus de la tête il y a UO.CharPrint.
• UO.Print ajoute une nouvelle entrée au journal des messages du jeu : lisez ou enregistrez d'abord la chaîne/le résultat de recherche souhaité, puis enregistrez le message de diagnostic. Dans une boucle rapide, enregistrez les messages lorsque des changements se produisent plutôt qu'à chaque itération.
• Sans couleur, hue 0x03B2 est utilisé. UO.Print(text, color) accepte le texte en premier ; UO.ColorPrint(color, text) – la couleur d'abord.
• UO.Print · UO.CharPrint · UO.Say · UO.ConColor

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 est une instruction séparée sans valeur de retour (void). Le texte du message figure directement dans l’appel.

UO.ColorPrint(0x0044, "Hello from C#");

1. Bref rapport - script direct

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

• Processed=12 — nombre de démonstration d'éléments déjà traités. Convert.ToString le transforme en chaîne. Cet exemple ne rapporte qu'un nombre ; il ne transfère pas les objets eux-mêmes.

var processed = 12;
UO.ColorPrint(0x0044, "Processed item entries: " + Convert.ToString(processed));

2. Avertissement de surcharge - Fonction de script

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

• Le poids et le maximum du personnage sont lus. Un maximum nul/inconnu n’est pas considéré comme une surcharge. Si poids >= maximum, une ligne est imprimée et Main se termine ; les objets ne sont pas jetés.

return  RunScenario();
 object? RunScenario()
{
    var weight = UO.Weight();
    var maximum = UO.MaxWeight();
    if (Truth(maximum > 0) && Truth(weight >= maximum))
    {
        UO.ColorPrint(0x0044, "Too heavy: " + Convert.ToString(weight) + "/" + Convert.ToString(maximum));
        return null;
    }

    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. Signaler les modifications de poids uniquement - Classe de script

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

• Main se souvient du poids, attend 1000 millisecondes et appelle le ReportWeight entièrement déclaré. L'assistant n'imprime que si le poids a changé et renvoie le nouveau poids pour le prochain contrôle. Il ne crée pas lui-même une boucle infinie.

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.Weight();
        UO.Wait(1000);
        previous = ReportWeight(previous, UO.Weight());
        return null;
    }

    dynamic ReportWeight(dynamic previous, dynamic current)
    {
        if (Truth(previous != current))
        {
            UO.ColorPrint(0x0044, "Weight changed: " + Convert.ToString(current));
        }

        return current;
    }

    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.ColorPrint(color, msg) — UO.ColorPrint(Any,Any)

Paramètres: color (Any), msg (Any)

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.ColorPrint.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Print: bridge.Print(NumberConversions.ToInt(color), msg.ToString()).
• InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(color).
• InjectionScript.Runtime.InjectionValue.ToString: msg.ToString().

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

public void ColorPrint(InjectionValue color, InjectionValue msg) => bridge.Print(NumberConversions.ToInt(color), msg.ToString());

---

UO.ConColor

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

Signatures C#

void UO.ConColor(object? color);

Définit UO hue pour les messages système ultérieurs de ce runtime de script.

Paramètres

• color - UO hue, pas RGB. Nombre ou chaîne hexadécimale ; le pont utilise les bits faibles 16. A ne pas confondre avec graphic/type. 0x0044 dans l'exemple est le hue sélectionné.

Valeur de retour

Un appel à une méthode avec un type de retour void est écrit sous la forme d'une instruction autonome C# ; le résultat ne peut pas être attribué ou vérifié. Le fait de remplir la déclaration ne constitue pas une confirmation de la part du serveur de jeu.

Comportement

• Affecte les UO.ClientPrint, UO.AddToJournal et UO.AddToSystemJournal suivants. Ne recolore pas les lignes précédentes, ne modifie pas le profil SpeechHue et ne change pas la couleur de UO.Print sans argument de couleur. L'ancien getter de couleur n'est pas là : stockez le hue régulier sélectionné dans sa variable.
• UO.Print · UO.CharPrint · UO.Say · UO.ConColor

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.ConColor");
UO.ConColor(0x0044);

1. UO.ConColor - 1 - script direct

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

• 0x0044 devient la couleur de la ligne système suivante. ConColor lui-même n'imprime rien.

UO.ConColor(0x0044);
UO.AddToSystemJournal("Notice");

2. UO.ConColor — 2 — fonction de script

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

• Le Print normal conserve sa couleur 0x03B2 et AddToJournal utilise le 0x0044 spécifié. Les deux messages sont locaux.

return  RunScenario();
 object? RunScenario()
{
    UO.ConColor(0x0044);
    UO.Print("Normal Print color");
    UO.AddToJournal("System color");
    return null;
}

3. UO.ConColor - 3 - classe de scénario

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

• usualHue=0x0440 est clairement la couleur normale sélectionnée, pas l'ancienne valeur lue. Le try utilise le 0x0035 temporaire ; finally renvoie usualHue, puis la ligne suivante est à nouveau imprimée en couleur normale.

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 usualHue = 0x0440;
        UO.ConColor(usualHue);
        try
        {
            UO.ConColor(0x0035);
            UO.AddToSystemJournal("Temporary warning");
        }
        finally
        {
            UO.ConColor(usualHue);
        }

        UO.AddToSystemJournal("Normal messages again");
        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.ConColor(color) — UO.ConColor(Any)

Paramètres: color (Any)

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.ConColor.
• InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(color).

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

public void ConColor(InjectionValue color)

        {

            systemMessageColor = NumberConversions.ToInt(color);

        }

---

UO.ConsolePrint

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

Signatures C#

void UO.ConsolePrint(object? msg);

Affiche un message local sur la progression du script ou la condition d'arrêt. Vous le voyez, pas les autres joueurs.

Paramètres

Valeur de retour

Un appel à une méthode avec un type de retour void est écrit sous la forme d'une instruction autonome C# ; le résultat ne peut pas être attribué ou vérifié. Le fait de remplir la déclaration ne constitue pas une confirmation de la part du serveur de jeu.

Comportement

• Le message va dans la zone inférieure gauche de la fenêtre de jeu et dans le journal local. Une copie est disponible en sortie IDE. Dans le journal général du manager, activez le filtre des messages du script : l'entrée est disponible sans la fenêtre de jeu. Le filtre de messages du système serveur ne sélectionne pas ces enregistrements. Le paquet vocal réseau n'est pas envoyé. Pour l'inscription au dessus de la tête il y a UO.CharPrint.
• UO.Print ajoute une nouvelle entrée au journal des messages du jeu : lisez ou enregistrez d'abord la chaîne/le résultat de recherche souhaité, puis enregistrez le message de diagnostic. Dans une boucle rapide, enregistrez les messages lorsque des changements se produisent plutôt qu'à chaque itération.
• Sans couleur, hue 0x03B2 est utilisé. UO.Print(text, color) accepte le texte en premier ; UO.ColorPrint(color, text) – la couleur d'abord.
• Malgré le nom de la console, il s'agit de la même sortie de jeu locale, et non d'un terminal Windows distinct.
• UO.Print · UO.CharPrint · UO.Say · UO.ConColor

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 est une instruction séparée sans valeur de retour (void). Le texte du message figure directement dans l’appel.

UO.ConsolePrint("Hello from C#");

1. Bref rapport - script direct

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

• Processed=12 — nombre de démonstration d'éléments déjà traités. Convert.ToString le transforme en chaîne. Cet exemple ne rapporte qu'un nombre ; il ne transfère pas les objets eux-mêmes.

var processed = 12;
UO.ConsolePrint("Processed item entries: " + Convert.ToString(processed));

2. Avertissement de surcharge - Fonction de script

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

• Le poids et le maximum du personnage sont lus. Un maximum nul/inconnu n’est pas considéré comme une surcharge. Si poids >= maximum, une ligne est imprimée et Main se termine ; les objets ne sont pas jetés.

return  RunScenario();
 object? RunScenario()
{
    var weight = UO.Weight();
    var maximum = UO.MaxWeight();
    if (Truth(maximum > 0) && Truth(weight >= maximum))
    {
        UO.ConsolePrint("Too heavy: " + Convert.ToString(weight) + "/" + Convert.ToString(maximum));
        return null;
    }

    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. Signaler les modifications de poids uniquement - Classe de script

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

• Main se souvient du poids, attend 1000 millisecondes et appelle le ReportWeight entièrement déclaré. L'assistant n'imprime que si le poids a changé et renvoie le nouveau poids pour le prochain contrôle. Il ne crée pas lui-même une boucle infinie.

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.Weight();
        UO.Wait(1000);
        previous = ReportWeight(previous, UO.Weight());
        return null;
    }

    dynamic ReportWeight(dynamic previous, dynamic current)
    {
        if (Truth(previous != current))
        {
            UO.ConsolePrint("Weight changed: " + Convert.ToString(current));
        }

        return current;
    }

    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.ConsolePrint(msg) — UO.ConsolePrint(Any)

Paramètres: msg (Any)

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.ConsolePrint.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Print: bridge.Print(msg.ToString()).
• InjectionScript.Runtime.InjectionValue.ToString: msg.ToString().

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

public void ConsolePrint(InjectionValue msg) => bridge.Print(msg.ToString());

---

UO.FillInfoWindow

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

Signatures C#

void UO.FillInfoWindow(object? s);

Ajoute une ligne à une fenêtre de texte et l'affiche.

Paramètres

• s — Texte de ligne ; la valeur est convertie en string.

Valeur de retour

void - aucune valeur de retour.

Comportement

• Les lignes précédemment accumulées sont conservées jusqu'à la limite MaxTextWindowLines.
• TextPrint ajoute une ligne et affiche YokoTextWindowGump lui-même ; TextOpen sécurise l'état ouvert. Lorsque le tampon déborde, les lignes les plus anciennes sont supprimées. Il s'agit d'une fenêtre de texte séparée, pas d'un serveur ni de UO.GetInfo.

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.FillInfoWindow");
UO.FillInfoWindow("Status ready");

1. Show line - direct script

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

• Le texte est envoyé à la fenêtre de texte du client.

UO.FillInfoWindow("Status ready");

2. Texte de la variable - fonction de script

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

• La chaîne est formée à partir du courant local HP.

return  RunScenario();
 object? RunScenario()
{
    var status = "HP: " + Convert.ToString(UO.GetHP());
    UO.FillInfoWindow(status);
    return null;
}

3. Deux lignes consécutives - classe de script

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

• La deuxième commande ajoute la seconde après la première.

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.FillInfoWindow("first");
        UO.FillInfoWindow("second");
        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.FillInfoWindow(s) — UO.FillInfoWindow(Any)

Paramètres: s (Any)

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.TextPrint: bridge.TextPrint(Text(0)).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Text: Text(0).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.TextOpen: bridge.TextOpen().

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

case "fillinfowindow":

                    bridge.TextPrint(Text(0));

                    bridge.TextOpen();

                    return InjectionValue.Unit;

---

UO.FillNewWindow

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

Signatures C#

void UO.FillNewWindow(object? s);

Efface la fenêtre de texte, ajoute une ligne et l'affiche.

Paramètres

• s — Texte de ligne ; la valeur est convertie en string.

Valeur de retour

void - aucune valeur de retour.

Comportement

• Avant TextPrint, TextClear est exécuté ; les lignes précédemment accumulées sont supprimées.
• TextPrint ajoute une ligne et affiche YokoTextWindowGump lui-même ; TextOpen sécurise l'état ouvert. Lorsque le tampon déborde, les lignes les plus anciennes sont supprimées. Il s'agit d'une fenêtre de texte séparée, pas d'un serveur ni de UO.GetInfo.

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.FillNewWindow");
UO.FillNewWindow("Status ready");

1. Show line - direct script

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

• Le texte est envoyé à la fenêtre de texte du client.

UO.FillNewWindow("Status ready");

2. Texte de la variable - fonction de script

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

• La chaîne est formée à partir du courant local HP.

return  RunScenario();
 object? RunScenario()
{
    var status = "HP: " + Convert.ToString(UO.GetHP());
    UO.FillNewWindow(status);
    return null;
}

3. Deux lignes consécutives - classe de script

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

• La deuxième commande remplace le contenu : ce qui reste est le deuxième.

return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        UO.FillNewWindow("first");
        UO.FillNewWindow("second");
        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.FillNewWindow(s) — UO.FillNewWindow(Any)

Paramètres: s (Any)

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.TextClear: bridge.TextClear().
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.TextPrint: bridge.TextPrint(Text(0)).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Text: Text(0).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.TextOpen: bridge.TextOpen().

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

case "fillnewwindow": bridge.TextClear(); bridge.TextPrint(Text(0)); bridge.TextOpen(); return InjectionValue.Unit;

---

UO.FontColor

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

Signatures C#

void UO.FontColor(object? color);

Définit hue au UO.UOAMessage local suivant de ce script. Ne change pas la couleur de la parole du personnage, ni le thème normal UO.Print, InfoFindList ou IDE.

Paramètres

• color — Index numérique obligatoire hue 0..65535, par exemple 0x0044. Ce n'est pas RGB. int est stocké à l'intérieur, et lorsque la sortie est réduite à ushort ; -1 ne signifie PAS réinitialiser et devient 65535. La valeur initiale du nouveau runtime est 0x03B2. Il n’y a pas de forme sans argument.

Valeur de retour

void : aucun résultat, ancienne couleur ou signe de réussite. Pour annuler votre paramètre ultérieurement, stockez le hue sélectionné dans une variable de script.

Comportement

• Change uniquement l'état.FontColor, n'imprime pas de message et n'envoie pas de paquet réseau.
• Valable jusqu'au prochain FontColor dans le même runtime. Un autre script indépendant possède son propre état. UO.Print(text,color) définit directement la couleur et ne lit pas FontColor.

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.FontColor");
UO.FontColor(0x0021);

1. Alerte d'inventaire en surbrillance - Script direct

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

• 0x0021 — indice hue ; La teinte finale dépend des fichiers de teintes du client. Le message est visible localement ; ce n'est pas prononcé par le personnage.

UO.FontColor(0x0021);
var first = UO.FindList("0x0EED", "backpack");
if (Truth(first == ""))
{
    UO.UOAMessage("No gold in the loaded backpack");
}
else
{
    UO.UOAMessage("Gold units: " + Convert.ToString(UO.FindFullQuantity()));
}

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

2. Procédure générale de notification des couleurs - Fonction de script

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

• L'avis complet accepte le texte et hue. Le dernier hue installé reste pour le prochain UOAMessage de ce runtime. Il n'y a pas de FontColor() intégré à lire ici.

return  RunScenario();
 object? RunScenario()
{
    Notice("Supplies checked", 0x0044);
    Notice("Restock needed", 0x0021);
    return null;
}

void Notice(dynamic text, dynamic hue)
{
    UO.FontColor(hue);
    UO.UOAMessage(text);
}

3. Revenir à la couleur de base connue - Classe de script

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

• 0x03B2 — valeur initiale FontColor du nouveau runtime. Enfin, renvoie exactement la base sélectionnée lors de la gestion normale de l'achèvement/des erreurs ; il ne restaure pas la valeur précédente inconnue.

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 baseHue = 0x03B2;
        try
        {
            UO.FontColor(0x0021);
            UO.UOAMessage("Check the route before moving");
        }
        finally
        {
            UO.FontColor(baseHue);
        }

        UO.UOAMessage("Ready");
        UO.Print("Regular Print keeps its own color");
        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.FontColor(color) — UO.FontColor(Any)

Paramètres: color (Any)

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
• InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::Arg: Arg(0, state.FontColor).

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

case "fontcolor": state.FontColor = Arg(0, state.FontColor); break;

---

UO.HelpRequest

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

Signatures C#

void UO.HelpRequest();

Demande le menu d'aide du serveur.

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

• ExecuteClientApiCompatibility appelle HelpRequest, qui envoie GameActions.RequestHelp via Invoke. Le contenu du menu est déterminé par le serveur.
• 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.HelpRequest");
UO.HelpRequest();

1. Appel direct - script direct

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

• Demande le menu d'aide du serveur.

UO.HelpRequest();

2. Option explicite - fonction de script

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

• ExecuteClientApiCompatibility appelle HelpRequest, qui envoie GameActions.RequestHelp via Invoke. Le contenu du menu est déterminé par le serveur.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.IsOnline()))
    {
        UO.HelpRequest();
    }

    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()
    {
        if (Truth(UO.IsOnline()))
        {
            UO.HelpRequest();
            UO.Print("Help requested");
        }

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

Paramètres: Aucun paramètre.

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.HelpRequest: bridge.HelpRequest().

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

case "helprequest": bridge.HelpRequest(); return InjectionValue.Unit;

---

UO.Hide

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

Signatures C#

void UO.Hide();
void UO.Hide(object? serial);

Supprime un élément chargé ou un autre personnage de l'écran ClassicUO. Aide à supprimer les objets interférents ; fonctionne avec des objets à l'intérieur des conteneurs et des échanges, des objets équipés sur la poupée de papier et dans ses petits emplacements d'équipement.

Paramètres

• serial — Numérique serial ou sa chaîne hexadécimale/décimale. Ce n'est pas type. Pour un objet nommé, obtenez d'abord la chaîne numérique via GetSerial(name). Sans argument, une cible locale apparaît.

Valeur de retour

void - aucune valeur de retour. Le résultat ne peut pas être attribué comme serial, graphic/type, quantité ou true/false. Les informations sont sorties vers l'interface/le journal plutôt que renvoyées au script.

Comportement

• Hide() ouvre un réticule local et rend immédiatement le contrôle au script. Cliquez sur un élément de la poupée en papier, un élément dans un conteneur ouvert ou un objet dans le monde. Escape annule la sélection.
• Hide(serial) agit immédiatement sur un objet chargé connu. Passez serial d'une pile/un élément spécifique plutôt que graphic/type. La pile sélectionnée est entièrement masquée, quel que soit le montant.
• L'article reste dans le conteneur : la quantité, le propriétaire, le contenu et l'état du serveur ne changent pas. FindType/GetContent peuvent toujours le trouver. Le masquage n'est pas un filtre de recherche, un report, une suppression, une compétence de masquage ou une invisibilité côté serveur.
• Le conteneur normal, la fenêtre d'échange et la grille de butin ne dessinent pas l'objet caché et n'acceptent pas les clics/glisser dessus. L'indicateur persiste lorsque la fenêtre est reconstruite et rouverte alors que le même objet chargé est en cours d'utilisation.
• L'objet équipé disparaît de la poupée en papier, de la petite fente et de l'image du personnage. Il reste équipé : le layer, l'armure et l'état sur le serveur ne changent pas. La robe cachée ne chevauche plus les sous-vêtements. L'image du personnage dans le gestionnaire est mise à jour en utilisant le même indicateur ; la liste des équipements actuels reste disponible.
• Hide ne cache pas son propre caractère, son terrain et sa statique. Le serial inexistant donne un message. Masquer le sac lui-même ne ferme pas la fenêtre de contenu déjà ouverte et ne masque pas automatiquement chaque élément inclus.
• Il n'y a pas de commande Afficher distincte dans le API actuel. Le masquage appartient à l'instance d'objet chargée : la supprimer du monde client et la charger à nouveau (par exemple, lors de la reconnexion) réinitialise l'indicateur. Le simple fait de fermer/ouvrir un coffre ne constitue pas un moyen garanti de retourner un article.

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

1. Cacher un objet dans un coffre ouvert - script direct

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

• Il n'y a pas de paramètres. Après avoir cliqué, seul l'élément sélectionné disparaît ; Le contenu du coffre sur le serveur ne change pas.

UO.Hide();
UO.Print("Select an item to hide locally");

2. Masquer la pile trouvée dans le sac à dos - fonction de script

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

• Hide reçoit ID du résultat de la recherche, pas 0x0EED. S'il n'y a aucun résultat, l'appel n'est pas exécuté. L'unité de Hide ne peut pas être comparée à true/false.

return  RunScenario();
 object? RunScenario()
{
    var item = UO.FindType(0x0EED, -1, "backpack");
    if (Truth(item == ""))
    {
        UO.Print("No loaded matching item");
        return null;
    }

    UO.Hide(item);
    UO.Print("Stack amount: " + Convert.ToString(UO.GetQuantity(item)));
    return null;
}

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

3. Masquer un élément spécifique d'un objet enregistré - classe de script

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

• L'objet nommé est d'abord résolu via GetSerial. Cocher Exists signifie une présence en mémoire, un masquage non réussi ou une disponibilité pour le transfert.

return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var item = UO.GetSerial("decoration");
        if (Truth(UO.Exists(item)) && Truth(item != UO.GetSerial("self")))
        {
            UO.Hide(item);
        }
        else
        {
            UO.Print("Select a loaded object other than self");
        }

        return null;
    }

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

4. Retirez la robe de l'image et laissez-la en place - script direct

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

• 22 est le numéro de couche, pas serial ou type. D'abord ObjAtLayer reçoit serial, puis Hide cache l'image de cette chose particulière. L'enlèvement et le transfert de l'article ne sont pas effectués ; la réouverture de paperdoll ne l'affiche pas.

var robe = UO.ObjAtLayer(22);
if (Truth(robe == 0))
{
    UO.Print("No robe equipped");
    return null;
}
UO.Hide(robe);

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

Paramètres: Aucun paramètre.

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.Hide.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.RequestInteractiveHideTarget: bridge.RequestInteractiveHideTarget().

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

public void Hide()

        {

            // Action command: the bridge owns UI/error reporting. A missing/non-interactive

            // target surface must not turn a void compatibility command into a script failure.

            bridge.RequestInteractiveHideTarget();

        }

UO.Hide(serial) — UO.Hide(Any)

Paramètres: serial (Any)

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.Hide.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.ClientHide: bridge.ClientHide(NumberConversions.ToInt(serial)).
• InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(serial).

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

public void Hide(InjectionValue serial)

        {

            bridge.ClientHide(NumberConversions.ToInt(serial));

        }

---

UO.Morph

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

Signatures C#

void UO.Morph(object? @type);

Modifie localement le graphic du personnage actuel.

Paramètres

• type - int body graphic ou la chaîne type résolue par ResolveType. 0 restaure graphic enregistré avec le premier Morph ; un nombre non nul est réduit à ushort.

Valeur de retour

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

Comportement

• Bridge.Morph sans Player ne change rien. La première fois qu'il est appelé, il enregistre _originalGraphic, puis l'attribue à Player.Graphic. Mises à jour du runtime ticksAnim=Timer même si le lecteur est manquant.
• Il s'agit d'une apparition locale, pas d'une transformation de serveur ou d'un changement de race/compétences disponibles. Les valeurs en dehors de ushort ne sont pas vérifiées par cette fonction de pont et sont réduites à 16 bits.

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.Morph");
UO.Morph("0x0190");

1. Appel direct - script direct

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

• Modifie localement le graphic du personnage actuel.

UO.Morph("0x0190");

2. Option explicite - fonction de script

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

• Bridge.Morph sans Player ne change rien. La première fois qu'il est appelé, il enregistre _originalGraphic, puis l'attribue à Player.Graphic. Mises à jour du runtime ticksAnim=Timer même si le lecteur est manquant.

return  RunScenario();
 object? RunScenario()
{
    UO.Morph(0);
    return null;
}

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

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

• Il s'agit d'une apparition locale, pas d'une transformation de serveur ou d'un changement de race/compétences disponibles. Les valeurs en dehors de ushort ne sont pas vérifiées par cette fonction de pont et sont réduites à 16 bits.

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.Morph("0x0190");
        UO.Wait(500);
        UO.Morph(0);
        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.Morph(type) — UO.Morph(Integer)

Paramètres: type (Integer/String)

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.Morph.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Morph: bridge.Morph(type).
• InjectionScript.Runtime.InjectionApiUO.Timer: Timer().

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

public void Morph(int type)

        {

            bridge.Morph(type);

            ticksAnim = Timer();

        }

UO.Morph(type) — UO.Morph(String)

Paramètres: type (Integer/String)

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.Morph.
• InjectionScript.Runtime.InjectionApiUO.Morph: Morph(ResolveType(type)).
• InjectionScript.Runtime.InjectionApiUO.ResolveType: ResolveType(type).

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

public void Morph(string type) => Morph(ResolveType(type));

---

UO.OpenIDE

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

Signatures C#

void UO.OpenIDE();
void UO.OpenIDE(object? filePath);

Paramètres

• filePath — Chemin facultatif. Vide/espace : ouvrez l'éditeur sans sélectionner de fichier ; le relatif est résolu à partir de _manager.AutoloadPath, l'absolu est conservé.

Valeur de retour

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

Comportement

• Bridge.OpenIDE prépare le chemin demandé, puis Invoke appelle YokoScriptEditorGump.Open(_world,requested). Le script du fichier n'est pas exécuté par la commande OpenIDE.
• L'éditeur est une fenêtre graphique, pas une application externe Launch. La lecture/affichage du fichier dépend de l'existence du chemin et de la logique de l'éditeur.

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

1. Appel direct - script direct

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

• Ouvre l'éditeur graphique C# IDE.

UO.OpenIDE();

2. Option explicite - fonction de script

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

• Bridge.OpenIDE prépare le chemin demandé, puis Invoke appelle YokoScriptEditorGump.Open(_world,requested). Le script du fichier n'est pas exécuté par la commande OpenIDE.

return  RunScenario();
 object? RunScenario()
{
    UO.OpenIDE("Example.csx");
    return null;
}

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

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

• L'éditeur est une fenêtre graphique, pas une application externe Launch. La lecture/affichage du fichier dépend de l'existence du chemin et de la logique de l'éditeur.

return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var path = "C:\\UO Scripts\\Example.csx";
        UO.OpenIDE(path);
        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.OpenIDE() — UO.OpenIDE()

Paramètres: Aucun paramètre.

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.OpenIDE.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.OpenIDE: bridge.OpenIDE(string.Empty).

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

public void OpenIDE() => bridge.OpenIDE(string.Empty);

UO.OpenIDE(filePath) — UO.OpenIDE(Any)

Paramètres: filePath (Any)

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.OpenIDE.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.OpenIDE: bridge.OpenIDE(filePath.ToString()).
• InjectionScript.Runtime.InjectionValue.ToString: filePath.ToString().

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

public void OpenIDE(InjectionValue filePath) => bridge.OpenIDE(filePath.ToString());

---

UO.Print

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

Signatures C#

void UO.Print(object? msg);
void UO.Print(object? msg, object? color);

Affiche un message local sur la progression du script ou la condition d'arrêt. Vous le voyez, pas les autres joueurs.

Paramètres

• color - UO hue, pas RGB. Nombre ou chaîne hexadécimale ; le pont utilise les bits faibles 16. A ne pas confondre avec graphic/type. 0x0044 dans l'exemple est le hue sélectionné. Sans couleur, hue 0x03B2 est utilisé. UO.Print(text, color) accepte le texte en premier ; UO.ColorPrint(color, text) – la couleur d'abord.

Valeur de retour

Un appel à une méthode avec un type de retour void est écrit sous la forme d'une instruction autonome C# ; le résultat ne peut pas être attribué ou vérifié. Le fait de remplir la déclaration ne constitue pas une confirmation de la part du serveur de jeu.

Comportement

• Le message va dans la zone inférieure gauche de la fenêtre de jeu et dans le journal local. Une copie est disponible en sortie IDE. Dans le journal général du manager, activez le filtre des messages du script : l'entrée est disponible sans la fenêtre de jeu. Le filtre de messages du système serveur ne sélectionne pas ces enregistrements. Le paquet vocal réseau n'est pas envoyé. Pour l'inscription au dessus de la tête il y a UO.CharPrint.
• UO.Print ajoute une nouvelle entrée au journal des messages du jeu : lisez ou enregistrez d'abord la chaîne/le résultat de recherche souhaité, puis enregistrez le message de diagnostic. Dans une boucle rapide, enregistrez les messages lorsque des changements se produisent plutôt qu'à chaque itération.
• Sans couleur, hue 0x03B2 est utilisé. UO.Print(text, color) accepte le texte en premier ; UO.ColorPrint(color, text) – la couleur d'abord.
• UO.Print · UO.CharPrint · UO.Say · UO.ConColor

Exemple .csx

UO.Print("C# script started");
UO.Print($"Position: {UO.GetX()}, {UO.GetY()}");

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 est une instruction séparée sans valeur de retour (void). Le texte du message figure directement dans l’appel.

UO.Print("Hello from C#");

1. Bref rapport - script direct

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

• Processed=12 — nombre de démonstration d'éléments déjà traités. Convert.ToString le transforme en chaîne. Cet exemple ne rapporte qu'un nombre ; il ne transfère pas les objets eux-mêmes.

var processed = 12;
UO.Print("Processed item entries: " + Convert.ToString(processed), 0x0044);

2. Avertissement de surcharge - Fonction de script

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

• Le poids et le maximum du personnage sont lus. Un maximum nul/inconnu n’est pas considéré comme une surcharge. Si poids >= maximum, une ligne est imprimée et Main se termine ; les objets ne sont pas jetés.

return  RunScenario();
 object? RunScenario()
{
    var weight = UO.Weight();
    var maximum = UO.MaxWeight();
    if (Truth(maximum > 0) && Truth(weight >= maximum))
    {
        UO.Print("Too heavy: " + Convert.ToString(weight) + "/" + Convert.ToString(maximum), 0x0044);
        return null;
    }

    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. Signaler les modifications de poids uniquement - Classe de script

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

• Main se souvient du poids, attend 1000 millisecondes et appelle le ReportWeight entièrement déclaré. L'assistant n'imprime que si le poids a changé et renvoie le nouveau poids pour le prochain contrôle. Il ne crée pas lui-même une boucle infinie.

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.Weight();
        UO.Wait(1000);
        previous = ReportWeight(previous, UO.Weight());
        return null;
    }

    dynamic ReportWeight(dynamic previous, dynamic current)
    {
        if (Truth(previous != current))
        {
            UO.Print("Weight changed: " + Convert.ToString(current), 0x0044);
        }

        return current;
    }

    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.Print(msg) — UO.Print(Any)

Paramètres: msg (Any)

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.Print.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Print: bridge.Print(msg.ToString()).
• InjectionScript.Runtime.InjectionValue.ToString: msg.ToString().

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

public void Print(InjectionValue msg)

        {

            bridge.Print(msg.ToString());

        }

UO.Print(msg, color) — UO.Print(Any,Any)

Paramètres: msg (Any), color (Any)

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.Print.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Print: bridge.Print(NumberConversions.ToInt(color), msg.ToString()).
• InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(color).
• InjectionScript.Runtime.InjectionValue.ToString: msg.ToString().

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

public void Print(InjectionValue msg, InjectionValue color)

        {

            bridge.Print(NumberConversions.ToInt(color), msg.ToString());

        }

---

UO.RemoveFigure

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

Signatures C#

dynamic UO.RemoveFigure(object? figureID);

Supprime une figure de carte locale par son ID.

Paramètres

• figureID - int ID, renvoyé AddFigure. Ce n'est pas un article serial ni un idiot ID.

Valeur de retour

int — le résultat de bridge.RemoveMapFigure : 1/0 par la présence d'une figure supprimée. L'entrée d'exécution est supprimée quel que soit le résultat du pont.

Comportement

• Appelle d'abord bridge.RemoveMapFigure, puis state.MapFigures.Remove(id), puis renvoie le résultat du pont. Inconnu ID ne crée pas de forme et ne déclenche pas d'action du serveur.
• La figure locale de la carte n'est pas un objet du monde. Les autres formes et géométries du serveur ne changent pas.
• WorldMapGump stocke les images dans le dictionnaire statique du processus. Les scripts/chats/macros réguliers d'un monde/profil utilisent un GetPersistentState commun et un compteur ID ; Les processus Individual Manager ne partagent pas de dessins. World.Clear/YokoScripts.Clear et l'état du profil de chargement n'effacent ni ne restaurent ce dictionnaire (le chargeur restaure uniquement UserStatics). Par conséquent, les dessins peuvent survivre à un changement de monde/de profil dans le même processus, en tenant compte de worldNum ; le nouvel état peut mettre à nouveau l'accent sur un dessin ID déjà existant. ClearFigures efface explicitement les dessins et les enregistrements d'état actuel. Succès - écriture/suppression de données, pas de preuve d'affichage.

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.

var id = UO.AddFigure(new object?[] { 0, 0, UO.X(), UO.Y(), UO.X() + 3, UO.Y(), 0, 0, 255 });
UO.Print("Removed flag: " + Convert.ToString(UO.RemoveFigure(id)));

1. Appel direct - script direct

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

• Supprime une figure de carte locale par son ID.

UO.Print(UO.RemoveFigure(1));

2. Option explicite - fonction de script

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

• Appelle d'abord bridge.RemoveMapFigure, puis state.MapFigures.Remove(id), puis renvoie le résultat du pont. Inconnu ID ne crée pas de forme et ne déclenche pas d'action du serveur.

return  RunScenario();
 object? RunScenario()
{
    dynamic[] figure = new dynamic[checked((int)(10) + 1)];
    figure[0] = 0;
    figure[1] = 0;
    figure[2] = UO.GetX();
    figure[3] = UO.GetY();
    figure[4] = UO.GetX() + 1;
    figure[5] = UO.GetY() + 1;
    figure[6] = 0;
    figure[7] = 0;
    figure[8] = 0;
    figure[9] = UO.WorldNum();
    figure[10] = "Example";
    var id = UO.AddFigure(figure);
    if (Truth(id > 0))
    {
        UO.Print(UO.RemoveFigure(id));
    }

    return null;
}

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

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

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

• La figure locale de la carte n'est pas un objet du monde. Les autres formes et géométries du serveur ne changent pas.

return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var id = 1;
        var first = UO.RemoveFigure(id);
        var second = UO.RemoveFigure(id);
        UO.Print(Convert.ToString(first) + " " + Convert.ToString(second));
        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.RemoveFigure(figureID) — UO.RemoveFigure(Any)

Paramètres: figureID (Any)

Résultat: dynamic / Any.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.RemoveMapFigure: bridge.RemoveMapFigure(id).

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

case "removefigure":

                {

                    int id = Arg(0);

                    int removed = bridge.RemoveMapFigure(id);

                    state.MapFigures.Remove(id);

                    return new InjectionValue(removed);

                }

---

UO.ServerPrint

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

Signatures C#

void UO.ServerPrint(object? message);

Affiche un message local sur la progression du script ou la condition d'arrêt. Vous le voyez, pas les autres joueurs.

Paramètres

Valeur de retour

Un appel à une méthode avec un type de retour void est écrit sous la forme d'une instruction autonome C# ; le résultat ne peut pas être attribué ou vérifié. Le fait de remplir la déclaration ne constitue pas une confirmation de la part du serveur de jeu.

Comportement

• Le message va dans la zone inférieure gauche de la fenêtre de jeu et dans le journal local. Une copie est disponible en sortie IDE. Dans le journal général du manager, activez le filtre des messages du script : l'entrée est disponible sans la fenêtre de jeu. Le filtre de messages du système serveur ne sélectionne pas ces enregistrements. Le paquet vocal réseau n'est pas envoyé. Pour l'inscription au dessus de la tête il y a UO.CharPrint.
• UO.Print ajoute une nouvelle entrée au journal des messages du jeu : lisez ou enregistrez d'abord la chaîne/le résultat de recherche souhaité, puis enregistrez le message de diagnostic. Dans une boucle rapide, enregistrez les messages lorsque des changements se produisent plutôt qu'à chaque itération.
• Sans couleur, hue 0x03B2 est utilisé. UO.Print(text, color) accepte le texte en premier ; UO.ColorPrint(color, text) – la couleur d'abord.
• Malgré le nom du serveur ou la similitude avec un message réseau, la commande n'imprime que le texte local. Pour parler au monde, utilisez UO.Say.
• UO.Print · UO.CharPrint · UO.Say · UO.ConColor

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 est une instruction séparée sans valeur de retour (void). Le texte du message figure directement dans l’appel.

UO.ServerPrint("Hello from C#");

1. Bref rapport - script direct

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

• Processed=12 — nombre de démonstration d'éléments déjà traités. Convert.ToString le transforme en chaîne. Cet exemple ne rapporte qu'un nombre ; il ne transfère pas les objets eux-mêmes.

var processed = 12;
UO.ServerPrint("Processed item entries: " + Convert.ToString(processed));

2. Avertissement de surcharge - Fonction de script

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

• Le poids et le maximum du personnage sont lus. Un maximum nul/inconnu n’est pas considéré comme une surcharge. Si poids >= maximum, une ligne est imprimée et Main se termine ; les objets ne sont pas jetés.

return  RunScenario();
 object? RunScenario()
{
    var weight = UO.Weight();
    var maximum = UO.MaxWeight();
    if (Truth(maximum > 0) && Truth(weight >= maximum))
    {
        UO.ServerPrint("Too heavy: " + Convert.ToString(weight) + "/" + Convert.ToString(maximum));
        return null;
    }

    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. Signaler les modifications de poids uniquement - Classe de script

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

• Main se souvient du poids, attend 1000 millisecondes et appelle le ReportWeight entièrement déclaré. L'assistant n'imprime que si le poids a changé et renvoie le nouveau poids pour le prochain contrôle. Il ne crée pas lui-même une boucle infinie.

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.Weight();
        UO.Wait(1000);
        previous = ReportWeight(previous, UO.Weight());
        return null;
    }

    dynamic ReportWeight(dynamic previous, dynamic current)
    {
        if (Truth(previous != current))
        {
            UO.ServerPrint("Weight changed: " + Convert.ToString(current));
        }

        return current;
    }

    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.ServerPrint(message) — UO.ServerPrint(String)

Paramètres: message (String)

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.ServerPrint.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.ServerPrint: bridge.ServerPrint(message).

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

public void ServerPrint(string message) => bridge.ServerPrint(message);

---

UO.SetShowZ

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

Signatures C#

void UO.SetShowZ(object? stateValue);

Modifie le runtime du drapeau local showZ.

Paramètres

• stateValue - 0 s'éteint ; tout entier non nul inclut.

Valeur de retour

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

Comportement

• Attribue à showZ la valeur de 0 ou 1 après NumberConversions.ToInt. Cette fonction elle-même ne modifie pas les coordonnées et n'envoie pas le paquet.
• Il s'agit du stockage de compatibilité du runtime actuel. Il n'y a aucun consommateur dans le projet privé mulPath/showZ ; le changement ne recharge pas les ressources et ne modifie pas l'affichage de la hauteur.

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

1. Appel direct - script direct

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

• Modifie le runtime du drapeau local showZ.

UO.SetShowZ(1);

2. Option explicite - fonction de script

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

• Attribue à showZ la valeur de 0 ou 1 après NumberConversions.ToInt. Cette fonction elle-même ne modifie pas les coordonnées et n'envoie pas le paquet.

return  RunScenario();
 object? RunScenario()
{
    UO.SetShowZ(0);
    return null;
}

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

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

• Il s'agit du stockage de compatibilité du runtime actuel. Il n'y a aucun consommateur dans le projet privé mulPath/showZ ; le changement ne recharge pas les ressources et ne modifie pas l'affichage de la hauteur.

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()
    {
        ApplyValue(1);
        return null;
    }

    void ApplyValue(dynamic value)
    {
        UO.SetShowZ(value);
    }
}

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.SetShowZ(stateValue) — UO.SetShowZ(Any)

Paramètres: stateValue (Any)

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.SetShowZ.
• InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(stateValue).

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

public void SetShowZ(InjectionValue stateValue) => showZ = NumberConversions.ToInt(stateValue) != 0 ? 1 : 0;

---

UO.SetSilentMode

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

Signatures C#

void UO.SetSilentMode(object? value);

Modifie le runtime du drapeau local SilentMode.

Paramètres

• value - 0 s'éteint ; tout entier non nul inclut.

Valeur de retour

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

Comportement

• Stocke SilentMode sous 0/1. GumpLinesResult lit le drapeau : avec 0 les résultats non vides GetGumpShortLines/GetGumpFullLines/GetGumpButtonsDescription sont en plus imprimés dans une fenêtre de texte et l'ouvrent ; avec 1 cet affichage supplémentaire est supprimé. Le tableau renvoyé ne change pas. Les autres sons Print et les messages du serveur ne sont pas supprimés.
• 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.SetSilentMode");
UO.SetSilentMode(1);

1. Appel direct - script direct

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

• Stocke SilentMode sous 0/1. GumpLinesResult lit le drapeau : avec 0 les résultats non vides GetGumpShortLines/GetGumpFullLines/GetGumpButtonsDescription sont en plus imprimés dans une fenêtre de texte et l'ouvrent ; avec 1 cet affichage supplémentaire est supprimé. Le tableau renvoyé ne change pas. Les autres sons Print et les messages du serveur ne sont pas supprimés.

UO.SetSilentMode(1);

2. Option explicite - fonction de script

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

• Stocke SilentMode sous 0/1. GumpLinesResult lit le drapeau : avec 0 les résultats non vides GetGumpShortLines/GetGumpFullLines/GetGumpButtonsDescription sont en plus imprimés dans une fenêtre de texte et l'ouvrent ; avec 1 cet affichage supplémentaire est supprimé. Le tableau renvoyé ne change pas. Les autres sons Print et les messages du serveur ne sont pas supprimés.

return  RunScenario();
 object? RunScenario()
{
    UO.SetSilentMode(0);
    return null;
}

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

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

• Stocke SilentMode sous 0/1. GumpLinesResult lit le drapeau : avec 0 les résultats non vides GetGumpShortLines/GetGumpFullLines/GetGumpButtonsDescription sont en plus imprimés dans une fenêtre de texte et l'ouvrent ; avec 1 cet affichage supplémentaire est supprimé. Le tableau renvoyé ne change pas. Les autres sons Print et les messages du serveur ne sont pas supprimés.

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()
    {
        ApplyValue(1);
        return null;
    }

    void ApplyValue(dynamic value)
    {
        UO.SetSilentMode(value);
    }
}

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.SetSilentMode(value) — UO.SetSilentMode(Any)

Paramètres: value (Any)

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).

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

case "setsilentmode": state.SilentMode = Arg(0) != 0 ? 1 : 0; return InjectionValue.Unit;

---

UO.ShowJournal

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

Signatures C#

void UO.ShowJournal();

Ouvre une fenêtre de journal du client local.

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

• ShowJournal appelle GameActions.OpenJournal(_world). Les enregistrements ne sont pas effacés et le texte n'est pas envoyé au serveur.
• Modifie ou affiche uniquement les données locales spécifiées. Cette commande n'a pas de confirmation du serveur.

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

1. Appel direct - script direct

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

• Ouvre une fenêtre de journal du client local.

UO.ShowJournal();

2. Option explicite - fonction de script

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

• ShowJournal appelle GameActions.OpenJournal(_world). Les enregistrements ne sont pas effacés et le texte n'est pas envoyé au serveur.

return  RunScenario();
 object? RunScenario()
{
    UO.Print("Journal example");
    UO.ShowJournal();
    return null;
}

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

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

• Modifie ou affiche uniquement les données locales spécifiées. Cette commande n'a pas de confirmation du serveur.

return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        UO.ShowJournal();
        UO.Print(UO.LineCount());
        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.ShowJournal() — UO.ShowJournal()

Paramètres: Aucun paramètre.

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.ShowJournal: bridge.ShowJournal().

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

case "showjournal": bridge.ShowJournal(); break;

---

UO.Snap

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

Signatures C#

int UO.Snap();
int UO.Snap(object? name);
int UO.Snap(object? name, object? quality);
int UO.Snap(object? file, object? quality, object? includeUI);

Enregistre un instantané de la fenêtre graphique du client.

Paramètres

• name — Nom de fichier facultatif. .jpg/.jpeg sélectionne JPEG, autre/aucun sélectionne PNG. Les répertoires du nom sont supprimés ; Seul le nom de base est utilisé.
• file — Nom de fichier facultatif. .jpg/.jpeg sélectionne JPEG, autre/aucun sélectionne PNG. Les répertoires du nom sont supprimés ; Seul le nom de base est utilisé.
• quality - Facultatif int, par défaut 100, limité à 1..100. Affecte JPEG ; PNG n'utilise pas de qualité avec perte.
• includeUI - Facultatif bool, par défaut true. false dessine le monde/éclairage sans UI.

Valeur de retour

Indicateur numérique int : 1 - fichier image enregistré, 0 - erreur de capture/écriture. Sans fenêtre graphique, RequireGameView renvoie une erreur avant TakeScreenshot.

Comportement

• TakeScreenshot écrit dans ExecutablePath/Data/Client/Screenshots, efface les caractères de nom invalides, sélectionne automatiquement le nom par date s'il est vide, ajoute _2/_3 s'il existe un fichier existant. Un chemin absolu arbitraire n’est pas utilisé.
• Avec UI lit le backbuffer ; sans UI crée RenderTarget2D et restitue le monde. JPEG active temporairement FNA_GRAPHICS_JPEG_SAVE_QUALITY avec restauration ; PNG SaveAsPng. Les erreurs à l'intérieur de TakeScreenshot sont enregistrées et indiquées sous la forme 0.

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

1. Appel direct - script direct

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

• Enregistre un instantané de la fenêtre graphique du client.

UO.Print(UO.Snap());

2. Option explicite - fonction de script

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

• TakeScreenshot écrit dans ExecutablePath/Data/Client/Screenshots, efface les caractères de nom invalides, sélectionne automatiquement le nom par date s'il est vide, ajoute _2/_3 s'il existe un fichier existant. Un chemin absolu arbitraire n’est pas utilisé.

return  RunScenario();
 object? RunScenario()
{
    UO.Print(UO.Snap("manual-example.jpg", 85));
    return null;
}

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

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

• Avec UI lit le backbuffer ; sans UI crée RenderTarget2D et restitue le monde. JPEG active temporairement FNA_GRAPHICS_JPEG_SAVE_QUALITY avec restauration ; PNG SaveAsPng. Les erreurs à l'intérieur de TakeScreenshot sont enregistrées et indiquées sous la forme 0.

return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        UO.Print(UO.Snap("manual-world.png", 100, false));
        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.Snap() — UO.Snap()

Paramètres: Aucun paramètre.

Résultat: int / Integer.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.Snap.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Snap: bridge.Snap(null, 100, true).

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

public int Snap() => bridge.Snap(null, 100, true);

UO.Snap(name) — UO.Snap(String)

Paramètres: name (String)

Résultat: int / Integer.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.Snap.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Snap: bridge.Snap(name, 100, true).

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

public int Snap(string name) => bridge.Snap(name, 100, true);

UO.Snap(name, quality) — UO.Snap(String,Integer)

Paramètres: name (String), quality (Integer)

Résultat: int / Integer.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.Snap.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Snap: bridge.Snap(name, Math.Max(1, Math.Min(100, quality)), true).

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

public int Snap(string name, int quality) => bridge.Snap(name, Math.Max(1, Math.Min(100, quality)), true);

UO.Snap(file, quality, includeUI) — UO.Snap(Any,Any,Any)

Paramètres: file (Any), quality (Any), includeUI (Any)

Résultat: int / Integer.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.Register [Snap].
• InjectionScript.Runtime.InjectionApiUO.Snap: Snap(values[0].ToString(), NumberConversions.ToInt(values[1]), ToBoolean(values[2])).
• InjectionScript.Runtime.InjectionValue.ToString: values[0].ToString().
• InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(values[1]).
• InjectionScript.Runtime.InjectionApiUO.ToBoolean: ToBoolean(values[2]).

L’appel exécute le delegate du gestionnaire enregistré. La méthode d’enregistrement crée ce delegate lors de la construction de l’API.

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

values => new InjectionValue(Snap(values[0].ToString(), NumberConversions.ToInt(values[1]), ToBoolean(values[2])))

---

UO.TextClear

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

Signatures C#

void UO.TextClear();

Efface le tampon de la fenêtre de texte locale.

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

• Efface _textWindow ; si la fenêtre était ouverte, la réaffiche avec une liste vide. Une fenêtre fermée reste fermée. Le journal client n'est pas effacé.
• L'action est une interface/tampon local ; Il n'y a aucun message réseau ni confirmation du serveur.

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

1. Appel direct - script direct

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

• Efface le tampon de la fenêtre de texte locale.

UO.TextClear();

2. Option explicite - fonction de script

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

• Efface _textWindow ; si la fenêtre était ouverte, la réaffiche avec une liste vide. Une fenêtre fermée reste fermée. Le journal client n'est pas effacé.

return  RunScenario();
 object? RunScenario()
{
    UO.TextPrint("Old line");
    UO.TextClear();
    return null;
}

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

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

• L'action est une interface/tampon local ; Il n'y a aucun message réseau ni confirmation du serveur.

return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        UO.TextClose();
        UO.TextClear();
        UO.TextOpen();
        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.TextClear() — UO.TextClear()

Paramètres: Aucun paramètre.

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.TextClear.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.TextClear: bridge.TextClear().

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

public void TextClear() => bridge.TextClear();

---

UO.TextClose

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

Signatures C#

void UO.TextClose();

Ferme la fenêtre de texte locale, en enregistrant le tampon.

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

• Définit _textWindowOpen=false et supprime le YokoTextWindowGump existant. La liste _textWindow n'est pas effacée ; TextOpen affichera à nouveau ses lignes.
• L'action est une interface/tampon local ; Il n'y a aucun message réseau ni confirmation du serveur.

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

1. Appel direct - script direct

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

• Ferme la fenêtre de texte locale, en enregistrant le tampon.

UO.TextClose();

2. Option explicite - fonction de script

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

• Définit _textWindowOpen=false et supprime le YokoTextWindowGump existant. La liste _textWindow n'est pas effacée ; TextOpen affichera à nouveau ses lignes.

return  RunScenario();
 object? RunScenario()
{
    UO.TextPrint("Retained line");
    UO.TextClose();
    return null;
}

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

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

• L'action est une interface/tampon local ; Il n'y a aucun message réseau ni confirmation du serveur.

return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        UO.TextPrint("Retained line");
        UO.TextClose();
        UO.Wait(250);
        UO.TextOpen();
        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.TextClose() — UO.TextClose()

Paramètres: Aucun paramètre.

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.TextClose.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.TextClose: bridge.TextClose().

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

public void TextClose() => bridge.TextClose();

---

UO.TextOpen

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

Signatures C#

void UO.TextOpen();

Ouvre une fenêtre de texte locale.

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

• Stocke _textWindowOpen=true et appelle YokoTextWindowGump.Show avec le _textWindow actuel. Le tampon n'est pas effacé ; la réouverture affiche les lignes accumulées.
• L'action est une interface/tampon local ; Il n'y a aucun message réseau ni confirmation du serveur.

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

1. Appel direct - script direct

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

• Ouvre une fenêtre de texte locale.

UO.TextOpen();

2. Option explicite - fonction de script

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

• Stocke _textWindowOpen=true et appelle YokoTextWindowGump.Show avec le _textWindow actuel. Le tampon n'est pas effacé ; la réouverture affiche les lignes accumulées.

return  RunScenario();
 object? RunScenario()
{
    UO.TextPrint("Example");
    UO.TextOpen();
    return null;
}

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

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

• L'action est une interface/tampon local ; Il n'y a aucun message réseau ni confirmation du serveur.

return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        UO.TextOpen();
        UO.Wait(500);
        UO.TextClose();
        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.TextOpen() — UO.TextOpen()

Paramètres: Aucun paramètre.

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.TextOpen.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.TextOpen: bridge.TextOpen().

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

public void TextOpen() => bridge.TextOpen();

---

UO.TextPrint

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

Signatures C#

void UO.TextPrint(object? text);

Ajoute une ligne à une fenêtre de texte locale et l'ouvre.

Paramètres

• text — Envoyez du texte via ToString ; enregistré comme transmis.

Valeur de retour

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

Comportement

• A la limite, MaxTextWindowLines=2000 supprime les anciennes lignes, puis ajoute du texte ou une ligne vide, définit _textWindowOpen=true et affiche la fenêtre. Ce n'est pas UO.Print dans le log et ce n'est pas un discours au serveur.
• L'action est une interface/tampon local ; Il n'y a aucun message réseau ni confirmation du serveur.

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

1. Appel direct - script direct

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

• Ajoute une ligne à une fenêtre de texte locale et l'ouvre.

UO.TextPrint("Example");

2. Option explicite - fonction de script

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

• A la limite, MaxTextWindowLines=2000 supprime les anciennes lignes, puis ajoute du texte ou une ligne vide, définit _textWindowOpen=true et affiche la fenêtre. Ce n'est pas UO.Print dans le log et ce n'est pas un discours au serveur.

return  RunScenario();
 object? RunScenario()
{
    var message = "Line 1";
    UO.TextPrint(message);
    UO.TextPrint("Line 2");
    return null;
}

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

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

• L'action est une interface/tampon local ; Il n'y a aucun message réseau ni confirmation du serveur.

return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        UO.TextClear();
        UO.TextPrint("Fresh report");
        UO.TextClose();
        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.TextPrint(text) — UO.TextPrint(String)

Paramètres: text (String)

Résultat: void / Unit.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.TextPrint.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.TextPrint: bridge.TextPrint(text).

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

public void TextPrint(string text) => bridge.TextPrint(text);

---

UO.UpdateFigure

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

Signatures C#

dynamic UO.UpdateFigure(object? figureID, object? figure);

Remplace la description d'une figure de carte locale existante.

Paramètres

• figureID - int ID dans l'état. MapFigures reçu par AddFigure. Inconnu ID donne 0.
• figure — Tableau ou chaîne avec | : [kind,coord,x1,y1,x2,y2,brushColor,brushStyle,color,worldNum,text]. Premiers champs numériques 9 minimum ; worldNum est la carte actuelle par défaut, le texte est vide par défaut.
• figure[0] (kind) - le type doit être 0..4, coord - 0..1, FigureID - positif. WorldMapGump.SetYokoMapFigure renvoie 0 lorsque ces limites sont violées.
• figure[1] (coord) - le type doit être 0..4, coord - 0..1, FigureID - positif. WorldMapGump.SetYokoMapFigure renvoie 0 lorsque ces limites sont violées.

Valeur de retour

Indicateur numérique int : 1 - l'analyse a réussi et le pont a été établi. SetMapFigure a renvoyé un résultat non nul, après quoi l'enregistrement a été mis à jour ; 0 - non ID, erreur de structure/champ de texte numérique ou échec du pont.

Comportement

• TryMapFigureArg accepte Array ou |string. Les premiers champs 9 sont convertis ; le texte numérique est vérifié par TryStr2Int. Vue/notation courte non prise en charge - 0, d'autres erreurs de conversion de vue peuvent interrompre le script.
• Si le pont échoue, l'entrée d'exécution existante n'est pas remplacée. En cas de succès, enregistre SerializeMapFigure avec les champs numériques et le texte 10. La figure est locale uniquement et ne constitue pas un élément de serveur.
• genre : 0 ligne, 1 ellipse (32 segment de contour), 2 contour rectangle, 3 flèche, 4 texte. coord=0 — coordonnées mondiales avec conversion en carte, coord=1 — pixels relatifs à la zone de dessin de la carte. x1/y1 et x2/y2 - extrémités/limites ; pour le monde, la flèche x2=y2=0 définit le début du joueur et l'objectif de x1/y1. couleur — 0x00BBGGRR (rouge mineur byte), couleur du contour. brushColor/brushStyle sont sauvegardés, mais le rendu ne les lit pas : il n'y a pas de remplissage. worldNum<0 s'affiche sur n'importe quelle carte, sinon uniquement celle spécifiée. Le texte est dessiné au premier point (+3 pixels pour les formes non textuelles) dans la police de la carte, et non dans la couleur du contour.
• WorldMapGump stocke les images dans le dictionnaire statique du processus. Les scripts/chats/macros réguliers d'un monde/profil utilisent un GetPersistentState commun et un compteur ID ; Les processus Individual Manager ne partagent pas de dessins. World.Clear/YokoScripts.Clear et l'état du profil de chargement n'effacent ni ne restaurent ce dictionnaire (le chargeur restaure uniquement UserStatics). Par conséquent, les dessins peuvent survivre à un changement de monde/de profil dans le même processus, en tenant compte de worldNum ; le nouvel état peut mettre à nouveau l'accent sur un dessin ID déjà existant. ClearFigures efface explicitement les dessins et les enregistrements d'état actuel. Succès - écriture/suppression de données, pas de preuve d'affichage.

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.

object?[] figure = { 0, 0, UO.X(), UO.Y(), UO.X() + 3, UO.Y(), 0, 0, 255 };
var id = UO.AddFigure(figure);
figure[8] = 65280;
UO.Print("Updated flag: " + Convert.ToString(UO.UpdateFigure(id, figure)));

1. Appel direct - script direct

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

• Remplace la description d'une figure de carte locale existante.

dynamic[] figure = new dynamic[checked((int)(8) + 1)];
figure[0] = 0;
figure[1] = 0;
figure[2] = 100;
figure[3] = 100;
figure[4] = 101;
figure[5] = 101;
figure[6] = 0;
figure[7] = 0;
figure[8] = 0;
UO.Print(UO.UpdateFigure(1, figure));

2. Option explicite - fonction de script

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

• TryMapFigureArg accepte Array ou |string. Les premiers champs 9 sont convertis ; le texte numérique est vérifié par TryStr2Int. Vue/notation courte non prise en charge - 0, d'autres erreurs de conversion de vue peuvent interrompre le script.

return  RunScenario();
 object? RunScenario()
{
    dynamic[] figure = new dynamic[checked((int)(10) + 1)];
    figure[0] = 0;
    figure[1] = 0;
    figure[2] = UO.GetX();
    figure[3] = UO.GetY();
    figure[4] = UO.GetX() + 1;
    figure[5] = UO.GetY() + 1;
    figure[6] = 0;
    figure[7] = 0;
    figure[8] = 0;
    figure[9] = UO.WorldNum();
    figure[10] = "Example";
    var id = UO.AddFigure(figure);
    if (Truth(id > 0))
    {
        UO.Print(UO.UpdateFigure(id, figure));
        UO.RemoveFigure(id);
    }

    return null;
}

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

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

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

• Si le pont échoue, l'entrée d'exécution existante n'est pas remplacée. En cas de succès, enregistre SerializeMapFigure avec les champs numériques et le texte 10. La figure est locale uniquement et ne constitue pas un élément de serveur.

return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var figure = "0|0|100|100|101|101|0|0|0";
        UO.Print(UO.UpdateFigure(1, figure));
        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.UpdateFigure(figureID, figure) — UO.UpdateFigure(Any,Any)

Paramètres: figureID (Any), figure (Any)

Résultat: dynamic / Any.

Pendant un appel:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::TryMapFigureArg: TryMapFigureArg(1, out int[] figure, out string figureText).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.SetMapFigure: bridge.SetMapFigure(id, figure[0], figure[1], figure[2], figure[3], figure[4], figure[5], figure[6], figure[7], figure[8], figure[9], figureText).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::SerializeMapFigure: SerializeMapFigure(figure, figureText).

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

case "updatefigure":

                {

                    int id = Arg(0);

                    if (!state.MapFigures.ContainsKey(id) || !TryMapFigureArg(1, out int[] figure, out string figureText))

                        return InjectionValue.False;

                    if (bridge.SetMapFigure(id, figure[0], figure[1], figure[2], figure[3], figure[4], figure[5], figure[6], figure[7], figure[8], figure[9], figureText) == 0)

                        return InjectionValue.False;

                    state.MapFigures[id] = SerializeMapFigure(figure, figureText);

                    return InjectionValue.True;

                }