Skip to content

FR UO Topic gumps

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

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

Fenêtres Gump

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

Lecture des fenêtres du serveur et envoi des réponses : boutons, cases à cocher, boutons radio et champs. La fenêtre ID, le propriétaire serial et l'index de la fenêtre ouverte ne sont pas interchangeables.

Sections

Sujet Commandes et explications
GetGump UO.GetGump
GetGumpInfo UO.GetGumpInfo
Gump ID / Serial UO.GetGumpID · UO.GetGumpSerial
Text Lines UO.GetGumpTextLines · UO.GetGumpFullLines · UO.GetGumpShortLines
Buttons UO.GetGumpButtonsDescription · UO.NumGumpButton
CheckBox UO.NumGumpCheckBox · UO.GumpAutoCheckBox
RadioButton UO.NumGumpRadiobutton · UO.GumpAutoRadiobutton
TextEntry UO.NumGumpTextEntry · UO.GumpAutoTextEntry
WaitGump UO.WaitGump
SelectGump UO.SelectGump
SendGumpSelect UO.SendGumpSelect
Ignore Gumps UO.AddGumpIgnoreByID · UO.AddGumpIgnoreBySerial · UO.ClearGumpsIgnore
Close Gump UO.IsGumpCanBeClosed · UO.CloseClientGump · UO.CancelGump

Toutes les commandes du thème

Informations sur Gump

UO.GetGump · UO.GetGumpID · UO.GetGumpSerial · UO.GetGumpCount · UO.GetGumpsCount · UO.GetGumpInfo · UO.GetGumpButtonsDescription · UO.GetGumpFullLines · UO.GetGumpShortLines · UO.GetGumpTextLines · UO.GumpObject · UO.LastGump · UO.IsGump · UO.GumpExists · UO.IsGumpCanBeClosed

Réponses

UO.NumGumpButton · UO.NumGumpCheckBox · UO.NumGumpRadiobutton · UO.NumGumpTextEntry · UO.GumpAutoCheckBox · UO.GumpAutoRadiobutton · UO.GumpAutoTextEntry · UO.WaitGump · UO.WaitGumpCheck · UO.WaitGumpEntry · UO.SelectGump · UO.SendGumpSelect · UO.SetGump

Ignore / Fermer

UO.AddGumpIgnoreByID · UO.AddGumpIgnoreBySerial · UO.ClearGumpsIgnore · UO.CancelGump · UO.CloseClientGump

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

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

var info = UO.GetGumpInfo(0);
if (Truth(ArrayLength(info) == 5))
{
    UO.Print("Serial=" + Hex(info[0]));
    UO.Print("GumpID=" + Hex(info[1]));
}

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;

UO.WaitGump

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

UO.WaitGump(100);
UO.UseObject("0x40001234");

Référence complète des commandes

UO.AddGumpIgnoreByID

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

Signatures C#

void UO.AddGumpIgnoreByID(object? id);

Ajoute le Gump numérique ID à la liste d'exceptions locales utilisée par UO.GetGumpInfo.

Paramètres

  • id est un Gump numérique ID qui renvoie UO.GetGumpInfo.

Valeur de retour

void. L'ajout de ID ne ferme pas la fenêtre et ne confirme pas que le serveur l'a traité.

Comportement

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

1. Éliminez le gump avec ID 123 du résultat de UO.GetGumpInfo. - scénario direct

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

  • Éliminez le gump avec ID 123 du résultat de UO.GetGumpInfo.
UO.AddGumpIgnoreByID(123);

2. Stockez ID dans une variable avant de lever l'exception. - fonction de script

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

  • Stockez ID dans une variable avant de lever l'exception.
return  RunScenario();
 object? RunScenario()
{
    var ignoredId = 123;
    UO.AddGumpIgnoreByID(ignoredId);
    return null;
}

3. Ajoutez du ID ; chaque exception affecte GetGumpInfo. - cours de script

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

  • Ajoutez du ID ; chaque exception affecte GetGumpInfo.
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.AddGumpIgnoreByID(123);
        UO.AddGumpIgnoreByID(456);
        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.AddGumpIgnoreByID(id) — UO.AddGumpIgnoreByID(Any)

Paramètres: id (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "addgumpignorebyid": state.IgnoredGumpIds.Add(Arg(0)); return InjectionValue.Unit;

UO.AddGumpIgnoreBySerial

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

Signatures C#

void UO.AddGumpIgnoreBySerial(object? serial);

Ajoute serial gump à la liste d'exceptions locales utilisée par UO.GetGumpInfo.

Paramètres

  • serial est un Gump numérique serial qui renvoie UO.GetGumpInfo.

Valeur de retour

void. L'ajout de serial ne ferme pas la fenêtre et ne confirme pas que le serveur l'a traité.

Comportement

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

1. Éliminez le gump avec serial 1073741824 du résultat UO.GetGumpInfo. - scénario direct

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

  • Éliminez le gump avec serial 1073741824 du résultat UO.GetGumpInfo.
UO.AddGumpIgnoreBySerial(1073741824);

2. Passez serial de la variable. - fonction de script

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

  • Passez serial de la variable.
return  RunScenario();
 object? RunScenario()
{
    var ignoredSerial = 1073741824;
    UO.AddGumpIgnoreBySerial(ignoredSerial);
    return null;
}

3. Éliminez deux gumps serial de la sortie de GetGumpInfo. - cours de script

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

  • Éliminez deux gumps serial de la sortie de GetGumpInfo.
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.AddGumpIgnoreBySerial(1073741824);
        UO.AddGumpIgnoreBySerial(1073741825);
        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.AddGumpIgnoreBySerial(serial) — UO.AddGumpIgnoreBySerial(Any)

Paramètres: serial (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "addgumpignorebyserial": state.IgnoredGumpSerials.Add(Arg(0)); return InjectionValue.Unit;

UO.CancelGump

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

Signatures C#

void UO.CancelGump();
void UO.CancelGump(object? gumpId);

Ferme le serveur Gump sélectionné via un résolveur compatible CloseSimpleGump.

Paramètres

  • gumpId - Facultatif int/valeur numérique. Le résolveur recherche d'abord un serveur/local correspondant serial, puis l'index gump du serveur. Sans argument, -1 est passé et le dernier gump est sélectionné.

Valeur de retour

void - aucune valeur de retour.

Comportement

  • Un argument nommé gumpId ne garantit pas de rechercher uniquement ID. CloseGumpUnsafe pour le serveur Gump envoie le bouton 0, puis supprime la fenêtre locale. Si Gump n'est pas trouvé, il n'y a aucune action. Ce n'est pas CancelMenu, et cela n'efface pas non plus le WaitGump en attente.

Scripts C# autonomes

Chaque exemple peut être enregistré dans un fichier séparé .csx et exécuté dans IDE. Les fonctions d'objet UO et d'attente fournissent l'hôte de la session de jeu en cours. Remplacez les noms, coordonnées et adresses de la démo serial par les vôtres.

Exemple simple

Exécutez ce code dans un fichier .csx séparé. Les arguments sont visibles dans l’appel ; remplacez les noms, serials et adresses d’exemple par les vôtres.

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

1. Fermer le dernier Gump - script direct

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

  • Le formulaire sans argument sélectionne le dernier Gump de serveur disponible.
UO.CancelGump();

2. Fermez Gump par ID connu - fonction de script

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

  • Le ID réel du premier gum est utilisé ; la liste peut changer entre les appels.
return  RunScenario();
 object? RunScenario()
{
    var id = UO.GetGumpID(0);
    if (Truth(id != 0))
    {
        UO.CancelGump(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. Dernier index explicite - classe de script

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

  • La valeur -1 sélectionne explicitement le dernier gump dans le résolveur.
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.CancelGump(-1);
        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.CancelGump() — UO.CancelGump()

Paramètres: Aucun paramètre.

Résultat: void / Unit.

Pendant un appel:

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

case "cancelgump": bridge.CloseSimpleGump(arguments.Length > 0 ? Arg(0) : -1); break;

UO.CancelGump(gumpId) — UO.CancelGump(Any)

Paramètres: gumpId (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "cancelgump": bridge.CloseSimpleGump(arguments.Length > 0 ? Arg(0) : -1); break;

UO.ClearGumpsIgnore

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

Signatures C#

void UO.ClearGumpsIgnore();

Efface les deux ensembles de runtime gump ID et gump serial ignorés.

Paramètres

Il n'y a pas de paramètres.

Valeur de retour

void - aucune valeur de retour.

Comportement

  • Ne ferme pas les fenêtres. Une fois effacé, GetGumpInfo peut à nouveau renvoyer un instantané du gump précédemment ignoré.

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

1. État clair - script direct

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

  • Efface les deux ensembles de runtime gump ID et gump serial ignorés.
UO.ClearGumpsIgnore();

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

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

  • Supprimez la règle d'ignorance ajoutée.
return  RunScenario();
 object? RunScenario()
{
    UO.AddGumpIgnoreByID(0x1234);
    UO.ClearGumpsIgnore();
    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.ClearGumpsIgnore();
        UO.ClearGumpsIgnore();
        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.ClearGumpsIgnore() — UO.ClearGumpsIgnore()

Paramètres: Aucun paramètre.

Résultat: void / Unit.

Pendant un appel:

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

case "cleargumpsignore":

                    state.IgnoredGumpIds.Clear(); state.IgnoredGumpSerials.Clear(); return InjectionValue.Unit;

UO.CloseClientGump

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

Signatures C#

void UO.CloseClientGump(object? id);

Supprime les gumps du serveur local dont le ServerSerial correspond au ID transmis.

Paramètres

  • id - int/numérique ID gump par rapport à ServerSerial. Ce n'est pas un index de liste, ni un serial local.

Valeur de retour

void - aucune valeur de retour.

Comportement

  • Parcourt ServerGumpsUnsafe, crée un instantané de toutes les correspondances et appelle Dispose. N'envoie pas le bouton 0 ou le résultat du formulaire au serveur. S'il n'y a pas de correspondance, rien ne change.

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

1. Fermez le premier Gump par ID - script direct

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

  • GetGumpID fournit le serveur ID ; CloseClientGump supprime les fenêtres locales correspondantes.
if (Truth(UO.GetGumpsCount() > 0))
{
    var id = UO.GetGumpID(0);
    UO.CloseClientGump(id);
}

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

2. ID de variable - fonction de script

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

  • Spécifiez ID du serveur Gump souhaité ; aucune correspondance n’est acceptable.
return  RunScenario();
 object? RunScenario()
{
    var id = 0x12345678;
    UO.CloseClientGump(id);
    return null;
}

3. Reclose - Classe de script

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

  • Après le premier Dispose, la deuxième fermeture ne trouve généralement plus la fenê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()
    {
        var id = UO.GetGumpID(0);
        if (Truth(id != 0))
        {
            UO.CloseClientGump(id);
            UO.CloseClientGump(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;
}

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.CloseClientGump(id) — UO.CloseClientGump(Any)

Paramètres: id (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "closeclientgump": bridge.CloseClientGump(Arg(0)); return InjectionValue.Unit;

UO.GetGump

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

Signatures C#

dynamic UO.GetGump(object? identifier);
dynamic UO.GetGump(object? gumpId, object? identifier);
dynamic UO.GetGump(object? gumpId, object? identifier, object? key);

Lit un champ du serveur Gump sélectionné. Vous permet de définir explicitement le sélecteur de fenêtre.

Paramètres

  • gumpId - Premier int facultatif dans les formes (gumpId,identifiant) ​​et (gumpId,identifiant,clé). int ou chaîne numérique : recherche d'abord une correspondance exacte GumpID/serial, puis l'index avec 0. -1 est le gump sélectionné par ce script, et s'il n'y est pas, le dernier de la liste courante. Les autres int négatifs conservent le 32-bit ID. Il s'agit d'un sélecteur, par opposition au strict GumpIndex dans NumGump*.
  • identifier - string insensible à la casse. Toutes les valeurs et types de résultats pris en charge sont répertoriés dans la section Retours. Le nom inconnu renvoie une chaîne vide.
  • key - Facultatif int, par défaut - 1. Indexez avec 0 pour bouton/texte/object/commande ; ce n'est pas un contrôle ID. Un index négatif et hors limites entraîne 0 pour le bouton ou une chaîne vide pour les champs de texte. Les autres identifiants n'utilisent pas de clé.

Valeur de retour

Le type du résultat dépend de l'identifiant. int : bouton – nombre de boutons réguliers ; bouton — ButtonID par clé d'index ; textlen — nombre d'éléments de texte disponibles ; injid — index de la fenêtre actuelle ; répondu — 0 (l'historique des réponses n'est pas stocké) ; inclient — 1 pour une fenêtre active trouvée, 0 si absente ; objectcount — nombre de contrôles en direct, y compris ceux imbriqués. string : serial et gumpid - chaînes hexadécimales 0xXXXXXXXX ; text — texte de l'élément à la clé d'index ; object — nom du type de contrôle ; command — description du contrôle (type, page, ID, coordonnées, dimensions et champs pris en charge). S'il n'y a pas de fenêtre, les identifiants numériques donnent 0, les identifiants de chaîne donnent une chaîne vide. injid=0 est également un premier indice valide : 0 à lui seul ne prouve pas l'absence de fenêtre. Ce n'est pas Array ou Pascal TGumpInfo.

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.
  • SelectGump/InfoGump spécifie la fenêtre sélectionnée uniquement dans le runtime actuel. Si la fenêtre sélectionnée est fermée, le dernier élément de la liste actuelle est utilisé, qui n'est pas nécessairement l'élément le plus récent dans le temps.
  • textlen/text fait référence aux contrôles de texte disponibles, et non au pool de chaînes d'origine du package serveur. object/command fait référence à l'ensemble de l'arborescence des contrôles en direct. Les index de différentes listes ne peuvent pas être mélangés.
  • Chaque appel lit l'état actuel séparément. Pour les serial, GumpID et listes correspondants, utilisez GetGumpInfo.

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

1. Lire ID de la fenêtre sélectionnée - script direct

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

  • gumpid et serial renvoient des chaînes déjà formatées en hexadécimal ; aucun Hex supplémentaire n’est nécessaire. Les lignes vides signifient qu'il n'y a pas de fenêtre lors de la lecture.
var id = UO.GetGump("gumpid");
var serial = UO.GetGump("serial");
UO.Print(id + " / " + serial);

2. Énumérer ButtonID - Fonction de script

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

  • Buttonlen — nombre de boutons ; i est l'index de la ligne de 0 à count-1. bouton - ID pour la réponse, pas pour les graphiques ou l'index. Lorsque vous changez de fenêtre, relisez la liste.
return  RunScenario();
 object? RunScenario()
{
    var count = UO.GetGump("buttonlen");
    var i = 0;
    while (Truth(i < count))
    {
        var button = UO.GetGump("button", i);
        UO.Print(Convert.ToString(button));
        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. Lire le texte après sélection - classe de script

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

  • 0x12345678 est un exemple de GumpID/serial, remplacez ID par le formulaire souhaité. text with key=0 lit le premier contrôle de texte disponible ; c'est une liste différente du bouton.
  • SelectGump signale l'absence de la fenêtre spécifiée, mais ne bloque pas la lecture ultérieure : vérifiez séparément le gumpid renvoyé si nécessaire.
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.SelectGump(0x12345678);
        if (Truth(UO.GetGump("inclient")))
        {
            var count = UO.GetGump("textlen");
            if (Truth(count > 0))
            {
                UO.Print(UO.GetGump("text", 0));
            }
        }

        return null;
    }

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

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.GetGump(identifier) — UO.GetGump(String)

Paramètres: identifier (String)

Résultat: dynamic / Any.

Pendant un appel:

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

public InjectionValue GetGump(string identifier) => LastGump(identifier, -1);

UO.GetGump(gumpId, identifier) — UO.GetGump(Integer,String)

Paramètres: gumpId (Integer/String), identifier (String/Integer)

Résultat: dynamic / Any.

Pendant un appel:

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

public InjectionValue GetGump(int gumpId, string identifier) => GetGump(gumpId, identifier, -1);

UO.GetGump(gumpId, identifier) — UO.GetGump(String,Integer)

Paramètres: gumpId (Integer/String), identifier (String/Integer)

Résultat: dynamic / Any.

Pendant un appel:

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

public InjectionValue GetGump(string identifier, int key) => LastGump(identifier, key);

UO.GetGump(gumpId, identifier, key) — UO.GetGump(Integer,String,Integer)

Paramètres: gumpId (Integer), identifier (String), key (Integer)

Résultat: dynamic / Any.

Pendant un appel:

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

public InjectionValue GetGump(int gumpId, string identifier, int key)

            => ConvertGumpValue(identifier, bridge.GetGumpValue(gumpId, identifier, key));

UO.GetGumpButtonsDescription

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

Signatures C#

dynamic UO.GetGumpButtonsDescription(object? gumpIndex);

Renvoie les descriptions des boutons Gump du serveur standard.

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

Array - descriptions des boutons normaux. [] - index invalide ou aucun élément correspondant. L'index de ligne commence par 0 ; ce n'est pas un contrôle ID.

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.
  • Chaque ligne contient ButtonID, action, toPage et graphiques. Les boutons radio ne sont pas des boutons de réponse ordinaires.
  • Lorsque SilentMode=0 le résultat non vide est également ajouté à la fenêtre de texte et l'ouvre. SetSilentMode(1) ne renvoie que le tableau.

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

1. Lire la première ligne - script direct

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

  • 0 — index de la fenêtre. ArrayLength vérifie la présence d'une ligne avant d'appeler des lignes[0].
var lines = UO.GetGumpButtonsDescription(0);
if (Truth(ArrayLength(lines) > 0))
{
    UO.Print(lines[0]);
}

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;

2. Parcourir toutes les lignes sans fenêtre automatique - fonction de script

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

  • SetSilentMode(1) désactive la fenêtre de texte supplémentaire. Le Print explicite dans l'exemple imprime toujours les chaînes.
  • i est l'index du tableau ; Prenez ID du bouton/interrupteur souhaité dans la description correspondante.
return  RunScenario();
 object? RunScenario()
{
    UO.SetSilentMode(1);
    var lines = UO.GetGumpButtonsDescription(0);
    var i = 0;
    while (Truth(i < ArrayLength(lines)))
    {
        UO.Print(lines[i]);
        i = i + 1;
    }

    return null;
}

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;

3. Lire les données de la dernière fenêtre de serveur ouverte - Classe de script

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

  • Le nombre est converti en index de la dernière fenêtre. Les données sont lues à partir du serveur Gump chargé ; les fenêtres locales ne sont pas incluses ici.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        int count = UO.GetGumpsCount();
        if (count == 0)
            return null;
        int index = count - 1;
        var lines = UO.GetGumpButtonsDescription(index);
        foreach (object? line in (object? [])lines)
            UO.Print(Convert.ToString(line) ?? "");
        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.GetGumpButtonsDescription(gumpIndex) — UO.GetGumpButtonsDescription(Any)

Paramètres: gumpIndex (Any)

Résultat: dynamic / Array.

Pendant un appel:

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

case "getgumpbuttonsdescription": return GumpLinesResult(bridge.GetGumpButtonsDescription(Arg(0)));

UO.GetGumpCount

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

Signatures C#

int UO.GetGumpCount();

Version courte GetGumpsCount : nombre de gumps de serveur actifs.

Paramètres

Il n'y a pas de paramètres.

Valeur de retour

int >= 0 — nombre de fenêtres, pas l'index de la dernière fenêtre. 0 — la liste est vide.

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.

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

1. Vérifier les fenêtres du serveur - script direct

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

  • Il s'agit du nombre de Gumps du serveur, pas de l'index de la fenêtre ; Le sac à dos local et la carte ne sont pas inclus ici.
int count = UO.GetGumpCount();
UO.Print($"Active server gumps: {count}");

2. Lire les ID de fenêtre ouverte - Fonction de script

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

  • Les index partent de zéro. La liste peut changer entre les appels, donc la quantité actuelle est vérifiée avant la lecture.
return  RunScenario();
 object? RunScenario()
{
    int count = UO.GetGumpCount();
    for (int index = 0; index < count; index++)
    {
        if (index >= UO.GetGumpCount())
            break;
        UO.Print($"Gump {index}: ID={UO.GetGumpID(index)}, serial={UO.GetGumpSerial(index)}");
    }

    return null;
}

3. Attendre la fenêtre chronométrée - classe de script

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

  • L'attente est limitée par un timeout. La simple présence d’une fenêtre ne prouve pas qu’il s’agisse d’un gâchis nécessaire ; pour sélectionner, cochez-le ID.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

    async public Task<object?> RunScenarioAsync()
    {
        bool appeared = await WaitForGump(3000);
        UO.Print(appeared ? "A server gump appeared" : "No server gump within the timeout");
        return null;
    }

    async Task<bool> WaitForGump(int timeoutMs)
    {
        var timer = System.Diagnostics.Stopwatch.StartNew();
        while (timer.ElapsedMilliseconds < timeoutMs)
        {
            if (UO.GetGumpCount() > 0)
                return true;
            await WaitAsync(50);
        }

        return false;
    }
}

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

Paramètres: Aucun paramètre.

Résultat: int / Integer.

Pendant un appel:

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

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

UO.GetGumpFullLines

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

Signatures C#

dynamic UO.GetGumpFullLines(object? gumpIndex);

Renvoie les descriptions de tous les éléments vivants, y compris les gumps de serveur imbriqués.

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

Array - descriptions de tous les éléments vivants, y compris ceux imbriqués. [] - index invalide ou aucun élément correspondant. L'index de ligne commence par 0 ; ce n'est pas un contrôle ID.

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.
  • Descriptions de l'arborescence de contrôle actuelle : type, page, ID, X/Y, tailles et champs pris en charge. Il ne s'agit pas d'un package de balisage de serveur brut.
  • Lorsque SilentMode=0 le résultat non vide est également ajouté à la fenêtre de texte et l'ouvre. SetSilentMode(1) ne renvoie que le tableau.

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

1. Lire la première ligne - script direct

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

  • 0 — index de la fenêtre. ArrayLength vérifie la présence d'une ligne avant d'appeler des lignes[0].
var lines = UO.GetGumpFullLines(0);
if (Truth(ArrayLength(lines) > 0))
{
    UO.Print(lines[0]);
}

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;

2. Parcourir toutes les lignes sans fenêtre automatique - fonction de script

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

  • SetSilentMode(1) désactive la fenêtre de texte supplémentaire. Le Print explicite dans l'exemple imprime toujours les chaînes.
  • i est l'index du tableau ; Prenez ID du bouton/interrupteur souhaité dans la description correspondante.
return  RunScenario();
 object? RunScenario()
{
    UO.SetSilentMode(1);
    var lines = UO.GetGumpFullLines(0);
    var i = 0;
    while (Truth(i < ArrayLength(lines)))
    {
        UO.Print(lines[i]);
        i = i + 1;
    }

    return null;
}

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;

3. Lire les données de la dernière fenêtre de serveur ouverte - Classe de script

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

  • Le nombre est converti en index de la dernière fenêtre. Les données sont lues à partir du serveur Gump chargé ; les fenêtres locales ne sont pas incluses ici.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        int count = UO.GetGumpsCount();
        if (count == 0)
            return null;
        int index = count - 1;
        var lines = UO.GetGumpFullLines(index);
        foreach (object? line in (object? [])lines)
            UO.Print(Convert.ToString(line) ?? "");
        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.GetGumpFullLines(gumpIndex) — UO.GetGumpFullLines(Any)

Paramètres: gumpIndex (Any)

Résultat: dynamic / Array.

Pendant un appel:

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

case "getgumpfulllines": return GumpLinesResult(bridge.GetGumpFullLines(Arg(0)));

UO.GetGumpID

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

Signatures C#

int UO.GetGumpID(object? gumpIndex);

Lit l'ID de type de fenêtre GumpID à partir de l'index Gump du serveur.

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

int — Identificateur de type de fenêtre 32 bits GumpID. 0 est un index invalide (serial=0 peut également être présent dans la fenêtre elle-même). Lorsque le bit le plus significatif est défini, int est négatif : utilisez Hex(value) pour afficher. Ce n'est pas un type d'un sujet ou un index.

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.
  • Pour une paire serial/GumpID correspondante, utilisez un GetGumpInfo : les champs info[0] et info[1].

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

1. Afficher ID en hexadécimal - script direct

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

  • 0 est le premier index de la liste des serveurs. Hex stocke la représentation binaire du int négatif.
var value = UO.GetGumpID(0);
UO.Print(Hex(value));

string Hex(object? value) => Convert.ToInt64(value).ToString("X");

2. Limite de la liste de contrôle - Fonction de script

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

  • Avec une liste immuable, le nombre est après le dernier index, donc manquant=0. Le dernier index valide est count-1.
return  RunScenario();
 object? RunScenario()
{
    var count = UO.GetGumpsCount();
    var missing = UO.GetGumpID(count);
    UO.Print(Hex(missing));
    return null;
}

string Hex(object? value) => Convert.ToInt64(value).ToString("X");

3. Rechercher une fenêtre ouverte par ID connu - classe de script

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

  • 0x999 est un exemple de ID ; remplacez-le par le vrai ID de la fenêtre souhaitée. Index, ID et serial propriétaire sont des valeurs différentes.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        int wantedId = 0x00000999;
        int count = UO.GetGumpsCount();
        for (int index = 0; index < count; index++)
        {
            if (index >= UO.GetGumpsCount())
                break;
            if (UO.GetGumpID(index) == wantedId)
            {
                UO.Print($"Gump index {index}, serial {UO.GetGumpSerial(index)}");
                return index;
            }
        }

        return -1;
        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.GetGumpID(gumpIndex) — UO.GetGumpID(Any)

Paramètres: gumpIndex (Any)

Résultat: int / Integer.

Pendant un appel:

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

case "getgumpid": return new InjectionValue(bridge.GetGumpId(Arg(0)));

UO.GetGumpInfo

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

Signatures C#

dynamic UO.GetGumpInfo(object? gumpIndex);

Renvoie un instantané cohérent des identifiants et des éléments d'un seul serveur Gump.

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

Tableau - exactement cinq éléments : [0] int serial ; [1] int GumpID ; [2] Tableau de textes non vides ; [3] Tableau descriptions des boutons normaux ; [4] Tableau descriptions de tous les éléments vivants, y compris ceux imbriqués. Un Gump invalide/fermé ou ignoré par ce script produit un tableau vide []. ID avec le bit le plus significatif est représenté par un int négatif. Un tableau de texte vide ne signifie pas en soi qu’il n’y a pas de fenêtre.

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.
  • L'intégralité de l'instantané est copiée dans une seule demande de fil de jeu. Changer/fermer la fenêtre après le retour ne modifie pas le tableau enregistré.
  • La description du champ indique le type, la page, ID, X/Y, les dimensions. Les boutons contiennent en outre ButtonID, action, toPage et graphic ; switches - ID, checked, inactive/active. Texts may contain spaces and =; La chaîne ne peut pas être analysée de manière inconditionnelle par des espaces.
  • AddGumpIgnoreByID/AddGumpIgnoreBySerial masque le résultat de cette lecture uniquement dans le script courant ; ClearGumpsIgnore supprime ces filtres. GetGumpsCount ne diminue 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.

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

1. Lisez les deux ID - script direct

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

  • GumpIndex=0 — le premier morceau de serveur. La vérification de la longueur protège l'accès aux champs de fenêtre manquants.
  • info[0] — serial, info[1] — GumpID; les deux appartiennent au même enregistrement.
var info = UO.GetGumpInfo(0);
if (Truth(ArrayLength(info) == 5))
{
    UO.Print("Serial=" + Hex(info[0]));
    UO.Print("GumpID=" + Hex(info[1]));
}

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;

2. Liste des vrais ButtonIDs - fonction de script

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

  • info[3] — tableau de descriptions de boutons ; le champ ButtonID dans la ligne spécifie ID pour la réponse. i est juste l'index de ligne, pas le ButtonID.
  • Les boutons radio sont des boutons radio et apparaissent dans info[4], pas dans la liste des boutons normaux.
return  RunScenario();
 object? RunScenario()
{
    var info = UO.GetGumpInfo(0);
    if (Truth(ArrayLength(info) == 5))
    {
        var buttons = info[3];
        var i = 0;
        while (Truth(i < ArrayLength(buttons)))
        {
            UO.Print(buttons[i]);
            i = i + 1;
        }
    }

    return null;
}

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;

3. Enregistrer le texte jusqu'à la fermeture - classe de script

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

  • info[2] - copie des textes. La fermeture n'est autorisée que pour la fenêtre non inhibée NoClose.
  • La fermeture n'efface pas les textes enregistrés ; Un tableau vide de textes est également acceptable pour une fenêtre existante.
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))
        {
            var texts = info[2];
            UO.CloseSimpleGump(0);
            if (Truth(ArrayLength(texts) > 0))
            {
                UO.Print(texts[0]);
            }
        }

        return null;
    }

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

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.GetGumpInfo(gumpIndex) — UO.GetGumpInfo(Any)

Paramètres: gumpIndex (Any)

Résultat: dynamic / Array.

Pendant un appel:

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

case "getgumpinfo":

                {

                    int index = Arg(0);

                    GumpSnapshot snapshot;

                    if (bridge is IApiGumpAccess reader)

                        snapshot = reader.ReadGump(index);

                    else

                    {

                        int id = bridge.GetGumpId(index);

                        snapshot = id == 0 ? null : new GumpSnapshot(bridge.GetGumpSerial(index), id,

                            bridge.GetGumpTextLines(index), bridge.GetGumpButtonsDescription(index), bridge.GetGumpFullLines(index));

                    }

                    if (snapshot == null || state.IgnoredGumpIds.Contains(snapshot.Id)

                        || state.IgnoredGumpSerials.Contains(snapshot.Serial))

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

                    return new InjectionValue(new[]

                    {

                        new InjectionValue(snapshot.Serial), new InjectionValue(snapshot.Id), StringArray(snapshot.Text),

                        StringArray(snapshot.Buttons), StringArray(snapshot.Controls)

                    });

                }

UO.GetGumpSerial

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

Signatures C#

int UO.GetGumpSerial(object? gumpIndex);

Lit le propriétaire de l'instance/de la fenêtre serial par index Gump du serveur.

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

int est le 32-bit serial de l'instance/propriétaire de la fenêtre. 0 est un index invalide (serial=0 peut également être présent dans la fenêtre elle-même). Lorsque le bit le plus significatif est défini, int est négatif : utilisez Hex(value) pour afficher. Ce n'est pas le type du sujet et ce n'est pas un index.

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.
  • Pour une paire serial/GumpID correspondante, utilisez un GetGumpInfo : les champs info[0] et info[1].

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

1. Afficher ID en hexadécimal - script direct

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

  • 0 est le premier index de la liste des serveurs. Hex stocke la représentation binaire du int négatif.
var value = UO.GetGumpSerial(0);
UO.Print(Hex(value));

string Hex(object? value) => Convert.ToInt64(value).ToString("X");

2. Limite de la liste de contrôle - Fonction de script

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

  • Avec une liste immuable, le nombre est après le dernier index, donc manquant=0. Le dernier index valide est count-1.
return  RunScenario();
 object? RunScenario()
{
    var count = UO.GetGumpsCount();
    var missing = UO.GetGumpSerial(count);
    UO.Print(Hex(missing));
    return null;
}

string Hex(object? value) => Convert.ToInt64(value).ToString("X");

3. Afficher les propriétaires de toutes les fenêtres de serveur chargées - classe de script

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

  • Serial appartient à la fenêtre du serveur ou à son propriétaire en vertu du contrat de commande. Il ne peut pas être utilisé à la place de l’index Gump.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        int count = UO.GetGumpsCount();
        for (int index = 0; index < count; index++)
        {
            if (index >= UO.GetGumpsCount())
                break;
            int serial = UO.GetGumpSerial(index);
            UO.Print($"Window {index}: serial={UO.Int2Hex(serial)}, ID={UO.GetGumpID(index)}");
        }

        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.GetGumpSerial(gumpIndex) — UO.GetGumpSerial(Any)

Paramètres: gumpIndex (Any)

Résultat: int / Integer.

Pendant un appel:

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

case "getgumpserial": return new InjectionValue(bridge.GetGumpSerial(Arg(0)));

UO.GetGumpShortLines

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

Signatures C#

dynamic UO.GetGumpShortLines(object? gumpIndex);

Renvoie les descriptions des éléments de texte et des boutons du serveur Gump.

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

Array - descriptions des éléments de texte et des boutons. [] - index invalide ou aucun élément correspondant. L'index de ligne commence par 0 ; ce n'est pas un contrôle ID.

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.
  • La liste restreinte exclut les décorations sans texte et sans type Button ; comprend des boutons radio.
  • Lorsque SilentMode=0 le résultat non vide est également ajouté à la fenêtre de texte et l'ouvre. SetSilentMode(1) ne renvoie que le tableau.

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

1. Lire la première ligne - script direct

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

  • 0 — index de la fenêtre. ArrayLength vérifie la présence d'une ligne avant d'appeler des lignes[0].
var lines = UO.GetGumpShortLines(0);
if (Truth(ArrayLength(lines) > 0))
{
    UO.Print(lines[0]);
}

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;

2. Parcourir toutes les lignes sans fenêtre automatique - fonction de script

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

  • SetSilentMode(1) désactive la fenêtre de texte supplémentaire. Le Print explicite dans l'exemple imprime toujours les chaînes.
  • i est l'index du tableau ; Prenez ID du bouton/interrupteur souhaité dans la description correspondante.
return  RunScenario();
 object? RunScenario()
{
    UO.SetSilentMode(1);
    var lines = UO.GetGumpShortLines(0);
    var i = 0;
    while (Truth(i < ArrayLength(lines)))
    {
        UO.Print(lines[i]);
        i = i + 1;
    }

    return null;
}

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;

3. Lire les données de la dernière fenêtre de serveur ouverte - Classe de script

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

  • Le nombre est converti en index de la dernière fenêtre. Les données sont lues à partir du serveur Gump chargé ; les fenêtres locales ne sont pas incluses ici.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        int count = UO.GetGumpsCount();
        if (count == 0)
            return null;
        int index = count - 1;
        var lines = UO.GetGumpShortLines(index);
        foreach (object? line in (object? [])lines)
            UO.Print(Convert.ToString(line) ?? "");
        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.GetGumpShortLines(gumpIndex) — UO.GetGumpShortLines(Any)

Paramètres: gumpIndex (Any)

Résultat: dynamic / Array.

Pendant un appel:

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

case "getgumpshortlines": return GumpLinesResult(bridge.GetGumpShortLines(Arg(0)));

UO.GetGumpTextLines

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

Signatures C#

dynamic UO.GetGumpTextLines(object? gumpIndex);

Renvoie les textes non vides des étiquettes, HTML, les champs de saisie et les étiquettes des commutateurs Gump du serveur.

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

Array — textes non vides des étiquettes, HTML, champs de saisie et étiquettes de commutateur. [] - index invalide ou aucun élément correspondant. L'index de ligne commence par 0 ; ce n'est pas un contrôle ID.

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.
  • Texte uniquement ; ButtonID, les dimensions et la structure ne sont pas inclus. N'imprime rien de plus.
  • GetGumpTextLines n'ouvre pas de fenêtre de texte.

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

1. Lire la première ligne - script direct

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

  • 0 — index de la fenêtre. ArrayLength vérifie la présence d'une ligne avant d'appeler des lignes[0].
var lines = UO.GetGumpTextLines(0);
if (Truth(ArrayLength(lines) > 0))
{
    UO.Print(lines[0]);
}

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;

2. Parcourir toutes les lignes sans fenêtre automatique - fonction de script

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

  • SetSilentMode(1) désactive la fenêtre de texte supplémentaire. Le Print explicite dans l'exemple imprime toujours les chaînes.
  • i est l'index du tableau ; Prenez ID du bouton/interrupteur souhaité dans la description correspondante.
return  RunScenario();
 object? RunScenario()
{
    UO.SetSilentMode(1);
    var lines = UO.GetGumpTextLines(0);
    var i = 0;
    while (Truth(i < ArrayLength(lines)))
    {
        UO.Print(lines[i]);
        i = i + 1;
    }

    return null;
}

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;

3. Lire les données de la dernière fenêtre de serveur ouverte - Classe de script

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

  • Le nombre est converti en index de la dernière fenêtre. Les données sont lues à partir du serveur Gump chargé ; les fenêtres locales ne sont pas incluses ici.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        int count = UO.GetGumpsCount();
        if (count == 0)
            return null;
        int index = count - 1;
        var lines = UO.GetGumpTextLines(index);
        foreach (object? line in (object? [])lines)
            UO.Print(Convert.ToString(line) ?? "");
        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.GetGumpTextLines(gumpIndex) — UO.GetGumpTextLines(Any)

Paramètres: gumpIndex (Any)

Résultat: dynamic / Array.

Pendant un appel:

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

case "getgumptextlines": return StringArray(bridge.GetGumpTextLines(Arg(0)));

UO.GetGumpsCount

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

Signatures C#

int UO.GetGumpsCount();

Renvoie le nombre de Gumps de serveur actifs.

Paramètres

Il n'y a pas de paramètres.

Valeur de retour

int >= 0 — nombre de fenêtres, pas l'index de la dernière fenêtre. 0 — la liste est vide.

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.

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

1. Rechercher Windows - script direct

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

  • Il n'y a pas d'arguments. count=0 signifie qu'il n'y a aucune fenêtre de serveur dans la liste actuelle.
var count = UO.GetGumpsCount();
if (Truth(count == 0))
{
    UO.Print("No server gumps");
}

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

2. Liste ID - fonction de script

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

  • i est l'index avec 0. Le ID résultant identifie les types de fenêtres plutôt que les positions dans la liste.
  • Si les fenêtres changent au cours de la promenade, la liste doit être relue ; count ne bloque pas l’interface.
return  RunScenario();
 object? RunScenario()
{
    var count = UO.GetGumpsCount();
    var i = 0;
    while (Truth(i < count))
    {
        UO.Print(Hex(UO.GetGumpID(i)));
        i = i + 1;
    }

    return null;
}

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;

3. Lire le dernier élément de la liste - classe de script

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

  • count-1 est le dernier index de la liste actuelle, et non une garantie de la fenêtre la plus récente. info est vide si la fenêtre a disparu avant la lecture.
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 count = UO.GetGumpsCount();
        if (Truth(count > 0))
        {
            var info = UO.GetGumpInfo(count - 1);
            UO.Print(ArrayLength(info));
        }

        return null;
    }

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

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

Paramètres: Aucun paramètre.

Résultat: int / Integer.

Pendant un appel:

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

case "getgumpscount": return new InjectionValue(bridge.GetGumpCount());

UO.GumpAutoCheckBox

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

Signatures C#

void UO.GumpAutoCheckBox(object? checkBoxID, object? value);

Définit la valeur de l'élément une fois dans le premier Gump de serveur approprié ; si l'élément n'existe pas encore, enregistre l'attente.

Paramètres

  • checkBoxID - int - exact ID de l'élément du type correspondant. Ce n'est pas un index, ni un GumpID, ni une fenêtre serial ; 0 est l'habituel ID, sans substitution du premier élément.
  • value - int - 1 activer, 0 désactiver. Les valeurs numériques non nulles incluent également : 0/1 sont recommandés. La sélection d'un bouton radio désélectionne les boutons radio voisins de son groupe.

Valeur de retour

void - ne renvoie rien : ni succès, ni nouvelle valeur, ni confirmation du serveur.

Comportement

  • Vérifie d’abord les fenêtres existantes dans l’ordre actuel de l’interface, puis les dispositions de serveur nouvelles ou mises à jour. Se déclenche une fois lors de la première correspondance de type et ID. Pour une fenêtre spécifique, utilisez NumGump* avec un index.
  • Tous les champs en attente sont appliqués avant les réponses automatiques des boutons. Répétez le même type et ID dans un script remplace une valeur qui n'a pas encore été exécutée. Limite — 1024 champs client en attente ; le dépassement provoque une erreur de script.
  • L'achèvement normal de la procédure évite l'attente. Annuler le propriétaire ou Terminate avec son nom supprime ses attentes ; TerminateAll supprime tout, y compris ceux qui restent après la fin des procédures. Changer le monde libère la file d’attente. Les attentes ne sont pas enregistrées dans le profil.

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

1. Remplissage immédiat - script direct

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

  • Le premier paramètre 33 est un exemple ID de l'élément souhaité ; remplacez-le par le vrai ID de InfoGump. La seconde est la valeur à définir. S'il n'y a aucun élément, l'action reste en attente.
UO.GumpAutoCheckBox(33, 1);

2. Remplir avant d'ouvrir - Fonction de script

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

  • 33 est ID de l'élément, 100 est un exemple de ButtonID de confirmation, 0x40001234 est serial de l'objet qui ouvre le formulaire. Remplacez les trois valeurs par les vôtres. Le champ sera rempli avant la réponse, même si la fenêtre arrive plus tard.
return  RunScenario();
 object? RunScenario()
{
    UO.GumpAutoCheckBox(33, 1);
    UO.WaitGump(100);
    UO.UseObject("0x40001234");
    return null;
}

3. Remplacement d'une valeur en attente - Classe de script

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

  • Les deux appels utilisent ID 33. Si l'élément n'est pas encore apparu, la dernière valeur s'applique. Si la fenêtre est déjà ouverte, les deux modifications sont effectuées immédiatement dans l'ordre.
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.GumpAutoCheckBox(33, 1);
        UO.GumpAutoCheckBox(33, 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.GumpAutoCheckBox(checkBoxID, value) — UO.GumpAutoCheckBox(Any,Any)

Paramètres: checkBoxID (Any), value (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "gumpautocheckbox": QueueGumpControl("checkbox", Arg(0), Text(1)); return InjectionValue.Unit;

UO.GumpAutoRadiobutton

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

Signatures C#

void UO.GumpAutoRadiobutton(object? radiobuttonID, object? value);

Définit la valeur de l'élément une fois dans le premier Gump de serveur approprié ; si l'élément n'existe pas encore, enregistre l'attente.

Paramètres

  • radiobuttonID - int - exact ID de l'élément du type correspondant. Ce n'est pas un index, ni un GumpID, ni une fenêtre serial ; 0 est l'habituel ID, sans substitution du premier élément.
  • value - int - 1 activer, 0 désactiver. Les valeurs numériques non nulles incluent également : 0/1 sont recommandés. La sélection d'un bouton radio désélectionne les boutons radio voisins de son groupe.

Valeur de retour

void - ne renvoie rien : ni succès, ni nouvelle valeur, ni confirmation du serveur.

Comportement

  • Vérifie d’abord les fenêtres existantes dans l’ordre actuel de l’interface, puis les dispositions de serveur nouvelles ou mises à jour. Se déclenche une fois lors de la première correspondance de type et ID. Pour une fenêtre spécifique, utilisez NumGump* avec un index.
  • Tous les champs en attente sont appliqués avant les réponses automatiques des boutons. Répétez le même type et ID dans un script remplace une valeur qui n'a pas encore été exécutée. Limite — 1024 champs client en attente ; le dépassement provoque une erreur de script.
  • L'achèvement normal de la procédure évite l'attente. Annuler le propriétaire ou Terminate avec son nom supprime ses attentes ; TerminateAll supprime tout, y compris ceux qui restent après la fin des procédures. Changer le monde libère la file d’attente. Les attentes ne sont pas enregistrées dans le profil.

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

1. Remplissage immédiat - script direct

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

  • Le premier paramètre 33 est un exemple ID de l'élément souhaité ; remplacez-le par le vrai ID de InfoGump. La seconde est la valeur à définir. S'il n'y a aucun élément, l'action reste en attente.
UO.GumpAutoRadiobutton(33, 1);

2. Remplir avant d'ouvrir - Fonction de script

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

  • 33 est ID de l'élément, 100 est un exemple de ButtonID de confirmation, 0x40001234 est serial de l'objet qui ouvre le formulaire. Remplacez les trois valeurs par les vôtres. Le champ sera rempli avant la réponse, même si la fenêtre arrive plus tard.
return  RunScenario();
 object? RunScenario()
{
    UO.GumpAutoRadiobutton(33, 1);
    UO.WaitGump(100);
    UO.UseObject("0x40001234");
    return null;
}

3. Remplacement d'une valeur en attente - Classe de script

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

  • Les deux appels utilisent ID 33. Si l'élément n'est pas encore apparu, la dernière valeur s'applique. Si la fenêtre est déjà ouverte, les deux modifications sont effectuées immédiatement dans l'ordre.
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.GumpAutoRadiobutton(33, 1);
        UO.GumpAutoRadiobutton(33, 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.GumpAutoRadiobutton(radiobuttonID, value) — UO.GumpAutoRadiobutton(Any,Any)

Paramètres: radiobuttonID (Any), value (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "gumpautoradiobutton": QueueGumpControl("radio", Arg(0), Text(1)); return InjectionValue.Unit;

UO.GumpAutoTextEntry

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

Signatures C#

void UO.GumpAutoTextEntry(object? textEntryID, object? value);

Définit la valeur de l'élément une fois dans le premier Gump de serveur approprié ; si l'élément n'existe pas encore, enregistre l'attente.

Paramètres

  • textEntryID - int - exact ID de l'élément du type correspondant. Ce n'est pas un index, ni un GumpID, ni une fenêtre serial ; 0 est l'habituel ID, sans substitution du premier élément.
  • value - string - texte du champ, comprenant une ligne vide à effacer. Les restrictions sur la longueur et les caractères autorisés du champ lui-même sont conservées.

Valeur de retour

void - ne renvoie rien : ni succès, ni nouvelle valeur, ni confirmation du serveur.

Comportement

  • Vérifie d’abord les fenêtres existantes dans l’ordre actuel de l’interface, puis les dispositions de serveur nouvelles ou mises à jour. Se déclenche une fois lors de la première correspondance de type et ID. Pour une fenêtre spécifique, utilisez NumGump* avec un index.
  • Tous les champs en attente sont appliqués avant les réponses automatiques des boutons. Répétez le même type et ID dans un script remplace une valeur qui n'a pas encore été exécutée. Limite — 1024 champs client en attente ; le dépassement provoque une erreur de script.
  • L'achèvement normal de la procédure évite l'attente. Annuler le propriétaire ou Terminate avec son nom supprime ses attentes ; TerminateAll supprime tout, y compris ceux qui restent après la fin des procédures. Changer le monde libère la file d’attente. Les attentes ne sont pas enregistrées dans le profil.
  • Le texte délimité par un champ peut être raccourci ou rejeté ; l'élément trouvé consomme toujours une action unique. La commande n'envoie pas de réponse de bouton et n'attend pas le serveur. Pour vérifier, utilisez GetGumpInfo/NumGumpTextEntry.

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.GumpAutoTextEntry");
UO.GumpAutoTextEntry(33, "500");

1. Remplissage immédiat - script direct

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

  • Le premier paramètre 33 est un exemple ID de l'élément souhaité ; remplacez-le par le vrai ID de InfoGump. La seconde est la valeur à définir. S'il n'y a aucun élément, l'action reste en attente.
UO.GumpAutoTextEntry(33, "500");

2. Remplir avant d'ouvrir - Fonction de script

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

  • 33 est ID de l'élément, 100 est un exemple de ButtonID de confirmation, 0x40001234 est serial de l'objet qui ouvre le formulaire. Remplacez les trois valeurs par les vôtres. Le champ sera rempli avant la réponse, même si la fenêtre arrive plus tard.
return  RunScenario();
 object? RunScenario()
{
    UO.GumpAutoTextEntry(33, "500");
    UO.WaitGump(100);
    UO.UseObject("0x40001234");
    return null;
}

3. Remplacement d'une valeur en attente - Classe de script

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

  • Les deux appels utilisent ID 33. Si l'élément n'est pas encore apparu, la dernière valeur s'applique. Si la fenêtre est déjà ouverte, les deux modifications sont effectuées immédiatement dans l'ordre.
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.GumpAutoTextEntry(33, "500");
        UO.GumpAutoTextEntry(33, "");
        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.GumpAutoTextEntry(textEntryID, value) — UO.GumpAutoTextEntry(Any,Any)

Paramètres: textEntryID (Any), value (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "gumpautotextentry": QueueGumpControl("textentry", Arg(0), Text(1)); return InjectionValue.Unit;

UO.GumpExists

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

Signatures C#

int UO.GumpExists(object? id);
int UO.GumpExists(object? firstId, object? secondId);

Vérifie la présence d'un serveur Gump à l'aide d'un sélecteur ou de la paire exacte serial/GumpID.

Paramètres

  • id — Forme à un argument : numérique serial, GumpID ou index avec 0. -1 ne sélectionne pas ici le dernier gump.
  • firstId — Forme à deux arguments : numérique 32-bit serial, y compris négatif int avec le bit le plus significatif.
  • secondId — Forme à deux arguments : GumpID exact de 32 bits. 0 est un nombre exact, pas un caractère générique. Seul -1 revient à la vérification à un argument de firstId comme serial/GumpID/index.

Valeur de retour

int - 1, si la fenêtre correspondante existe maintenant ; 0 sinon. Ne renvoie pas l'index, serial ou le nombre de correspondances.

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.
  • Le contrôle ne sélectionne pas de fenêtre et ne la réserve pas. Le couple ID est vérifié dans son ensemble ; ID avec le bit le plus significatif ne désactive pas le filtre.

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

1. Vérifiez ID connu - script direct

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

  • 0x87654321 — le GumpID ou serial souhaité. Un argument ne fait pas de distinction entre ces espaces ID.
var exists = UO.GumpExists(0x87654321);
UO.Print(Convert.ToString(exists));

2. Vérifier la paire exacte - fonction de script

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

  • Le premier numéro est serial, le second est GumpID. Les deux sont négatifs dans le int signé, mais la comparaison préserve tous les bits 32.
return  RunScenario();
 object? RunScenario()
{
    var exists = UO.GumpExists(0x87654321, 0x98765432);
    if (Truth(exists))
    {
        UO.Print("Matching pair exists");
    }

    return null;
}

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

3. Vérifier les identifiants enregistrés - Classe de script

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

  • info[0]/info[1] appartiennent à la même image. exist=1 signifie que la paire existe maintenant ; une fenêtre rouverte avec la même paire n'est pas différente de la précédente.
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))
        {
            var exists = UO.GumpExists(info[0], info[1]);
            UO.Print(Convert.ToString(exists));
        }

        return null;
    }

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

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.GumpExists(id) — UO.GumpExists(Any)

Paramètres: id (Any)

Résultat: int / Integer.

Pendant un appel:

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

public int GumpExists(InjectionValue id) => bridge.GumpExists(NumberConversions.ToInt(id), -1);

UO.GumpExists(firstId, secondId) — UO.GumpExists(Any,Any)

Paramètres: firstId (Any), secondId (Any)

Résultat: int / Integer.

Pendant un appel:

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

public int GumpExists(InjectionValue firstId, InjectionValue secondId)

            => bridge.GumpExists(NumberConversions.ToInt(firstId), NumberConversions.ToInt(secondId));

UO.GumpObject

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

Signatures C#

void UO.GumpObject(object? gumpId);

Sélectionne un serveur Gump existant pour les appels ultérieurs.

Paramètres

  • gumpId - int : correspond d'abord à LocalSerial ou ServerSerial, puis indexe zéro dans la liste de Gumps actuelle. Ce ne sont pas des boutons ID.

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.SelectGump enregistre _selectedServerGump. Si serial ne correspond pas, prend l'index 0..count-1. Introuvable - le Gump sélectionné devient null et un message s'affiche.
  • Gump ne s'ouvre pas et aucune réponse n'est envoyée au serveur. Les index changent lorsque les fenêtres sont ouvertes/fermées ; pour une sélection stable, utilisez le serial/id actuel.

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

1. Appel direct - script direct

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

  • Sélectionne un serveur Gump existant pour les appels ultérieurs.
if (Truth(UO.GumpExists(0)))
{
    UO.GumpObject(0);
}

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

2. Option explicite - fonction de script

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

  • Bridge.SelectGump enregistre _selectedServerGump. Si serial ne correspond pas, prend l'index 0..count-1. Introuvable - le Gump sélectionné devient null et un message s'affiche.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.GetGumpsCount() > 0))
    {
        var serial = UO.GetGumpSerial(0);
        UO.GumpObject(serial);
    }

    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 :

  • Gump ne s'ouvre pas et aucune réponse n'est envoyée au serveur. Les index changent lorsque les fenêtres sont ouvertes/fermées ; pour une sélection stable, utilisez le serial/id actuel.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        if (Truth(UO.GetGumpsCount() > 0))
        {
            UO.GumpObject(0);
            UO.Print(UO.LastGump("gumpid"));
        }

        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.GumpObject(gumpId) — UO.GumpObject(Any)

Paramètres: gumpId (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "gumpobject": bridge.SelectGump(Arg(0)); break;

UO.IsGump

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

Signatures C#

int UO.IsGump();

Vérifie s'il existe au moins un serveur Gump actif.

Paramètres

Il n'y a pas de paramètres.

Valeur de retour

int — 1, si la liste n'est pas vide ; 0 si vide. C'est un signe de disponibilité, pas le nombre de fenêtres.

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.

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

1. Lecture conditionnelle – Script direct

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

  • Il n'y a pas d'arguments. GetGumpInfo(0) lit le premier élément et peut renvoyer un tableau vide si la fenêtre a déjà été fermée.
if (Truth(UO.IsGump()))
{
    var info = UO.GetGumpInfo(0);
    UO.Print(ArrayLength(info));
}

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;

2. Distinguer quantité et présence - fonction script

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

  • Avec trois fenêtres stables présentes=1, count=3.
return  RunScenario();
 object? RunScenario()
{
    var present = UO.IsGump();
    var count = UO.GetGumpsCount();
    UO.Print(Convert.ToString(present) + "/" + Convert.ToString(count));
    return null;
}

3. Attente limitée - Classe de script

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

  • N'attendez pas plus d'environ 3000 ms, vérifiez toutes les 50 ms. Le cadeau final montre l'état après l'attente.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

    async public Task<object?> RunScenarioAsync()
    {
        var started = Now();
        while (Truth(UO.IsGump() == 0) && Truth(Now() - started < 3000))
        {
            await Delay(50);
        }

        var present = UO.IsGump();
        return null;
    }

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

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

Paramètres: Aucun paramètre.

Résultat: int / Integer.

Pendant un appel:

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

case "isgump": return new InjectionValue(bridge.GetGumpCount() > 0 ? 1 : 0);

UO.IsGumpCanBeClosed

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

Signatures C#

int UO.IsGumpCanBeClosed(object? gumpIndex);

Vérifie si la fermeture locale par clic droit du serveur Gump est autorisée.

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

int — 1, si la fenêtre existe et CanCloseWithRightClick est activée ; sinon 0. Ceci n’est pas dû à la fermeture ou à la présence d’un bouton Annuler.

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.
  • NoClose interdit CloseSimpleGump ; la possibilité d'envoyer ButtonID au serveur est une action distincte.

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

1. Clôture conditionnelle - script direct

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

  • 0 — index de la fenêtre. La vérification et la clôture sont des défis différents ; l'indice peut changer entre eux.
if (Truth(UO.IsGumpCanBeClosed(0)))
{
    UO.CloseSimpleGump(0);
}

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

2. Afficher la désactivation de la fermeture - Fonction de script

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

  • closesable=0 sur une fenêtre existante signifie que la fenêtre ne peut pas être fermée, pas l'absence de la fenêtre.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.GetGumpsCount() > 0))
    {
        var closable = UO.IsGumpCanBeClosed(0);
        UO.Print(Convert.ToString(closable));
    }

    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. Index non valide - classe de script

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

  • -1 n'est pas valide pour cette commande d'index et donne 0 ; Ce n'est pas la dernière sélection de fenê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()
    {
        var result = UO.IsGumpCanBeClosed(-1);
        UO.Print(Convert.ToString(result));
        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.IsGumpCanBeClosed(gumpIndex) — UO.IsGumpCanBeClosed(Any)

Paramètres: gumpIndex (Any)

Résultat: int / Integer.

Pendant un appel:

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

case "isgumpcanbeclosed": return new InjectionValue(bridge.IsGumpCanBeClosed(Arg(0)));

UO.LastGump

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

Signatures C#

dynamic UO.LastGump(object? identifier);
dynamic UO.LastGump(object? identifier, object? key);

Lit un champ du serveur Gump sélectionné. Utilise la fenêtre sélectionnée par ce script ou le dernier élément de la liste courante.

Paramètres

  • identifier - string insensible à la casse. Toutes les valeurs et types de résultats pris en charge sont répertoriés dans la section Retours. Le nom inconnu renvoie une chaîne vide.
  • key - Facultatif int, par défaut - 1. Indexez avec 0 pour bouton/texte/object/commande ; ce n'est pas un contrôle ID. Un index négatif et hors limites entraîne 0 pour le bouton ou une chaîne vide pour les champs de texte. Les autres identifiants n'utilisent pas de clé.

Valeur de retour

Le type du résultat dépend de l'identifiant. int : bouton – nombre de boutons réguliers ; bouton — ButtonID par clé d'index ; textlen — nombre d'éléments de texte disponibles ; injid — index de la fenêtre actuelle ; répondu — 0 (l'historique des réponses n'est pas stocké) ; inclient — 1 pour une fenêtre active trouvée, 0 si absente ; objectcount — nombre de contrôles en direct, y compris ceux imbriqués. string : serial et gumpid - chaînes hexadécimales 0xXXXXXXXX ; text — texte de l'élément à la clé d'index ; object — nom du type de contrôle ; command — description du contrôle (type, page, ID, coordonnées, dimensions et champs pris en charge). S'il n'y a pas de fenêtre, les identifiants numériques donnent 0, les identifiants de chaîne donnent une chaîne vide. injid=0 est également un premier indice valide : 0 à lui seul ne prouve pas l'absence de fenêtre. Ce n'est pas Array ou Pascal TGumpInfo.

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.
  • SelectGump/InfoGump spécifie la fenêtre sélectionnée uniquement dans le runtime actuel. Si la fenêtre sélectionnée est fermée, le dernier élément de la liste actuelle est utilisé, qui n'est pas nécessairement l'élément le plus récent dans le temps.
  • textlen/text fait référence aux contrôles de texte disponibles, et non au pool de chaînes d'origine du package serveur. object/command fait référence à l'ensemble de l'arborescence des contrôles en direct. Les index de différentes listes ne peuvent pas être mélangés.
  • Chaque appel lit l'état actuel séparément. Pour les serial, GumpID et listes correspondants, utilisez GetGumpInfo.

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

1. Lire ID de la fenêtre sélectionnée - script direct

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

  • gumpid et serial renvoient des chaînes déjà formatées en hexadécimal ; aucun Hex supplémentaire n’est nécessaire. Les lignes vides signifient qu'il n'y a pas de fenêtre lors de la lecture.
var id = UO.LastGump("gumpid");
var serial = UO.LastGump("serial");
UO.Print(id + " / " + serial);

2. Énumérer ButtonID - Fonction de script

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

  • Buttonlen — nombre de boutons ; i est l'index de la ligne de 0 à count-1. bouton - ID pour la réponse, pas pour les graphiques ou l'index. Lorsque vous changez de fenêtre, relisez la liste.
return  RunScenario();
 object? RunScenario()
{
    var count = UO.LastGump("buttonlen");
    var i = 0;
    while (Truth(i < count))
    {
        var button = UO.LastGump("button", i);
        UO.Print(Convert.ToString(button));
        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. Lire le texte après sélection - classe de script

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

  • 0x12345678 est un exemple de GumpID/serial, remplacez ID par le formulaire souhaité. text with key=0 lit le premier contrôle de texte disponible ; c'est une liste différente du bouton.
  • SelectGump signale l'absence de la fenêtre spécifiée, mais ne bloque pas la lecture ultérieure : vérifiez séparément le gumpid renvoyé si nécessaire.
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.SelectGump(0x12345678);
        if (Truth(UO.LastGump("inclient")))
        {
            var count = UO.LastGump("textlen");
            if (Truth(count > 0))
            {
                UO.Print(UO.LastGump("text", 0));
            }
        }

        return null;
    }

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

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.LastGump(identifier) — UO.LastGump(String)

Paramètres: identifier (String)

Résultat: dynamic / Any.

Pendant un appel:

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

public InjectionValue LastGump(string identifier) => LastGump(identifier, -1);

UO.LastGump(identifier, key) — UO.LastGump(String,Integer)

Paramètres: identifier (String), key (Integer)

Résultat: dynamic / Any.

Pendant un appel:

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

public InjectionValue LastGump(string identifier, int key) => ConvertGumpValue(identifier, bridge.GetGumpValue(-1, identifier, key));

UO.NumGumpButton

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

Signatures C#

int UO.NumGumpButton(object? gumpIndex, object? value);

Active un bouton Gump de serveur existant en fonction de l'index de fenêtre strict et de l'ID de bouton exact.

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.
  • value - int - ButtonID à partir de la description d'un bouton normal. Pas le numéro de ligne, pas le bouton graphic, pas le GumpID.

Valeur de retour

int (bool) - 1, si la fenêtre et le bouton sont trouvés et que l'action locale est effectuée ; 0 s'il n'y a pas de fenêtre/bouton. Changer la page renvoie également 1. Ceci ne constitue pas une confirmation du traitement du serveur.

Le résultat de la commande est un indicateur numérique : 1 signifie une condition remplie, 0 signifie une condition non remplie. Après var result = command(...) vérifiez si (result != 0) ou if (result == 0). Enregistrez le résultat d'un appel : un appel répété peut effectuer à nouveau l'action ou lire l'état qui a déjà changé.

Comportement

  • 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.
  • Le bouton SwitchPage change de page localement. Le bouton Activer provoque une réponse instinctive ; la fenêtre se ferme généralement. Contrairement à SendGumpSelect, cette commande nécessite un ButtonID existant dans l'arborescence de contrôle.

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

1. Appuyez sur un bouton bien connu - script direct

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

  • 0 est l'index de la fenêtre, 77 est un exemple de ButtonID de l'inspecteur. Votre formulaire a besoin de son vrai ID.
var ok = UO.NumGumpButton(0, 77);
if (Truth(ok == 0))
{
    UO.Print("Button not found");
}

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

2. Vérifiez d'abord le type de fenêtre - Fonction de script

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

  • 0x12345678 est le GumpID attendu, 100 est le ButtonID. Ces deux nombres appartiennent à des espaces ID différents.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.GetGumpID(0) == 0x12345678))
    {
        var ok = UO.NumGumpButton(0, 100);
    }

    return null;
}

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

3. Changer la case à cocher avant le bouton - Classe de script

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

  • 33 - case à cocher ID, 1 - activer, 100 - bouton ID. L’état de la case à cocher sera inclus dans la réponse uniquement pour le bouton Activer.
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.NumGumpCheckBox(0, 33, 1)))
        {
            var ok = UO.NumGumpButton(0, 100);
        }

        return null;
    }

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

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.NumGumpButton(gumpIndex, value) — UO.NumGumpButton(Any,Any)

Paramètres: gumpIndex (Any), value (Any)

Résultat: int / Integer.

Pendant un appel:

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

case "numgumpbutton": return (bridge is IApiGumpAccess buttons

                    ? buttons.ActivateGumpButtonAtIndex(Arg(0), Arg(1)) : bridge.ActivateGumpButton(Arg(0), Arg(1))) != 0 ? InjectionValue.True : InjectionValue.False;

UO.NumGumpCheckBox

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

Signatures C#

int UO.NumGumpCheckBox(object? gumpIndex, object? cbid, object? value);

Définit l'état de l'indicateur dans le serveur Gump par index.

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.
  • cbid - int - l'élément ID exact de la description de Gump. Il ne s'agit pas du numéro de série de l'élément ; le ID manquant n'est pas remplacé par un index.
  • value - int - 1 activer/sélectionner, 0 désactiver. Les valeurs numériques non nulles, true et cochées sont également reconnues. 0 et 1 sont recommandés.

Valeur de retour

int (bool) — 1, si l'élément requis est trouvé et que sa valeur finale correspond à celle spécifiée ; 0 si l'index est invalide, le type ID/element est manquant, ou si le champ n'a pas pris une valeur exacte. La réinitialisation d'une valeur déjà définie réussit également.

Le résultat de la commande est un indicateur numérique : 1 signifie une condition remplie, 0 signifie une condition non remplie. Après var result = command(...) vérifiez si (result != 0) ou if (result == 0). Enregistrez le résultat d'un appel : un appel répété peut effectuer à nouveau l'action ou lire l'état qui a déjà changé.

Comportement

  • 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.
  • Modifie l'état local. Les champs et boutons radio cochés sont envoyés suivis de la réponse du bouton.
  • La sélection d'un bouton radio désélectionne le bouton radio adjacent du même groupe ; les cases à cocher régulières sont indépendantes.

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

1. Définissez la valeur et vérifiez le résultat - script direct

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

  • 0 — index de la fenêtre ; 33 — exact CBID ; 1 - nouvelle valeur. Remplacez 33 par ID de votre gump.
var ok = UO.NumGumpCheckBox(0, 33, 1);
if (Truth(ok == 0))
{
    UO.Print("Control missing or value rejected");
}

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

2. Effacer la valeur - Fonction de script

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

  • 0 efface le champ ou le décoche. Le succès du changement est renvoyé, et non la nouvelle valeur du champ.
return  RunScenario();
 object? RunScenario()
{
    var ok = UO.NumGumpCheckBox(0, 33, 0);
    UO.Print(Convert.ToString(ok));
    return null;
}

3. Remplir avant de répondre - Classe de script

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

  • 100 - exemple de confirmation ButtonID du serveur ; il doit être remplacé ID de votre fenêtre. 0 à SendGumpSelect(0,100) est l'index de la fenêtre.
  • La réponse peut fermer le gump et modifier les index. envoyé désigne un envoi local, résultat d'une opération non confirmée par le serveur.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        if (Truth(UO.NumGumpCheckBox(0, 33, 1)))
        {
            var sent = UO.SendGumpSelect(0, 100);
            UO.Print(Convert.ToString(sent));
        }

        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.NumGumpCheckBox(gumpIndex, cbid, value) — UO.NumGumpCheckBox(Any,Any,Any)

Paramètres: gumpIndex (Any), cbid (Any), value (Any)

Résultat: int / Integer.

Pendant un appel:

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

case "numgumpcheckbox": return SetIndexedGumpValue(Arg(0), "checkbox", Arg(1), Text(2));

UO.NumGumpRadiobutton

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

Signatures C#

int UO.NumGumpRadiobutton(object? gumpIndex, object? radiobuttonID, object? value);

Définit l'état d'un bouton radio dans un serveur Gump par index.

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.
  • radiobuttonID - int - l'élément ID exact de la description de Gump. Il ne s'agit pas du numéro de série de l'élément ; le ID manquant n'est pas remplacé par un index.
  • value - int - 1 activer/sélectionner, 0 désactiver. Les valeurs numériques non nulles, true et cochées sont également reconnues. 0 et 1 sont recommandés.

Valeur de retour

int (bool) — 1, si l'élément requis est trouvé et que sa valeur finale correspond à celle spécifiée ; 0 si l'index est invalide, le type ID/element est manquant, ou si le champ n'a pas pris une valeur exacte. La réinitialisation d'une valeur déjà définie réussit également.

Le résultat de la commande est un indicateur numérique : 1 signifie une condition remplie, 0 signifie une condition non remplie. Après var result = command(...) vérifiez si (result != 0) ou if (result == 0). Enregistrez le résultat d'un appel : un appel répété peut effectuer à nouveau l'action ou lire l'état qui a déjà changé.

Comportement

  • 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.
  • Modifie l'état local. Les champs et boutons radio cochés sont envoyés suivis de la réponse du bouton.
  • La sélection d'un bouton radio désélectionne le bouton radio adjacent du même groupe ; les cases à cocher régulières sont indépendantes.

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

1. Définissez la valeur et vérifiez le résultat - script direct

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

  • 0 — index de la fenêtre ; 33 — RadiobuttonID exact ; 1 - nouvelle valeur. Remplacez 33 par ID de votre gump.
var ok = UO.NumGumpRadiobutton(0, 33, 1);
if (Truth(ok == 0))
{
    UO.Print("Control missing or value rejected");
}

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

2. Effacer la valeur - Fonction de script

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

  • 0 efface le champ ou le décoche. Le succès du changement est renvoyé, et non la nouvelle valeur du champ.
return  RunScenario();
 object? RunScenario()
{
    var ok = UO.NumGumpRadiobutton(0, 33, 0);
    UO.Print(Convert.ToString(ok));
    return null;
}

3. Remplir avant de répondre - Classe de script

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

  • 100 - exemple de confirmation ButtonID du serveur ; il doit être remplacé ID de votre fenêtre. 0 à SendGumpSelect(0,100) est l'index de la fenêtre.
  • La réponse peut fermer le gump et modifier les index. envoyé désigne un envoi local, résultat d'une opération non confirmée par le serveur.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        if (Truth(UO.NumGumpRadiobutton(0, 33, 1)))
        {
            var sent = UO.SendGumpSelect(0, 100);
            UO.Print(Convert.ToString(sent));
        }

        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.NumGumpRadiobutton(gumpIndex, radiobuttonID, value) — UO.NumGumpRadiobutton(Any,Any,Any)

Paramètres: gumpIndex (Any), radiobuttonID (Any), value (Any)

Résultat: int / Integer.

Pendant un appel:

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

case "numgumpradiobutton": return SetIndexedGumpValue(Arg(0), "radio", Arg(1), Text(2));

UO.NumGumpTextEntry

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

Signatures C#

int UO.NumGumpTextEntry(object? gumpIndex, object? textEntryID, object? value);

Définit le texte du champ de saisie dans le serveur Gump par index.

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.
  • textEntryID - int - l'élément ID exact de la description de Gump. Il ne s'agit pas du numéro de série de l'élément ; le ID manquant n'est pas remplacé par un index.
  • value - string - nouveau texte. Une chaîne vide efface le champ ; les restrictions de longueur/caractère sur le champ lui-même sont conservées.

Valeur de retour

int (bool) — 1, si l'élément requis est trouvé et que sa valeur finale correspond à celle spécifiée ; 0 si l'index est invalide, le type ID/element est manquant, ou si le champ n'a pas pris une valeur exacte. La réinitialisation d'une valeur déjà définie réussit également.

Le résultat de la commande est un indicateur numérique : 1 signifie une condition remplie, 0 signifie une condition non remplie. Après var result = command(...) vérifiez si (result != 0) ou if (result == 0). Enregistrez le résultat d'un appel : un appel répété peut effectuer à nouveau l'action ou lire l'état qui a déjà changé.

Comportement

  • 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.
  • Modifie l'état local. Les champs et boutons radio cochés sont envoyés suivis de la réponse du bouton.
  • La sélection d'un bouton radio désélectionne le bouton radio adjacent du même groupe ; les cases à cocher régulières sont indépendantes.

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.NumGumpTextEntry(0, 33, "500");
UO.Print("NumGumpTextEntry: " + Convert.ToString(result));

1. Définissez la valeur et vérifiez le résultat - script direct

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

  • 0 — index de la fenêtre ; 33 — exact TextEntryID ; '500' est la nouvelle valeur. Remplacez 33 par ID de votre gump.
var ok = UO.NumGumpTextEntry(0, 33, "500");
if (Truth(ok == 0))
{
    UO.Print("Control missing or value rejected");
}

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

2. Effacer la valeur - Fonction de script

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

  • '' efface le champ ou le décoche. Le succès du changement est renvoyé, et non la nouvelle valeur du champ.
return  RunScenario();
 object? RunScenario()
{
    var ok = UO.NumGumpTextEntry(0, 33, "");
    UO.Print(Convert.ToString(ok));
    return null;
}

3. Remplir avant de répondre - Classe de script

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

  • 100 - exemple de confirmation ButtonID du serveur ; il doit être remplacé ID de votre fenêtre. 0 à SendGumpSelect(0,100) est l'index de la fenêtre.
  • La réponse peut fermer le gump et modifier les index. envoyé désigne un envoi local, résultat d'une opération non confirmée par le serveur.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        if (Truth(UO.NumGumpTextEntry(0, 33, "500")))
        {
            var sent = UO.SendGumpSelect(0, 100);
            UO.Print(Convert.ToString(sent));
        }

        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.NumGumpTextEntry(gumpIndex, textEntryID, value) — UO.NumGumpTextEntry(Any,Any,Any)

Paramètres: gumpIndex (Any), textEntryID (Any), value (Any)

Résultat: int / Integer.

Pendant un appel:

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

case "numgumptextentry": return SetIndexedGumpValue(Arg(0), "textentry", Arg(1), Text(2));

UO.SelectGump

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

Signatures C#

void UO.SelectGump(object? id);

Sélectionne un serveur Gump existant pour les appels ultérieurs.

Paramètres

  • id - int : correspond d'abord à LocalSerial ou ServerSerial, puis indexe zéro dans la liste de Gumps actuelle. Ce ne sont pas des boutons ID.

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.SelectGump enregistre _selectedServerGump. Si serial ne correspond pas, prend l'index 0..count-1. Introuvable - le Gump sélectionné devient null et un message s'affiche.
  • Gump ne s'ouvre pas et aucune réponse n'est envoyée au serveur. Les index changent lorsque les fenêtres sont ouvertes/fermées ; pour une sélection stable, utilisez le serial/id actuel.

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

1. Appel direct - script direct

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

  • Sélectionne un serveur Gump existant pour les appels ultérieurs.
if (Truth(UO.GumpExists(0)))
{
    UO.SelectGump(0);
}

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

2. Option explicite - fonction de script

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

  • Bridge.SelectGump enregistre _selectedServerGump. Si serial ne correspond pas, prend l'index 0..count-1. Introuvable - le Gump sélectionné devient null et un message s'affiche.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.GetGumpsCount() > 0))
    {
        var serial = UO.GetGumpSerial(0);
        UO.SelectGump(serial);
    }

    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 :

  • Gump ne s'ouvre pas et aucune réponse n'est envoyée au serveur. Les index changent lorsque les fenêtres sont ouvertes/fermées ; pour une sélection stable, utilisez le serial/id actuel.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        if (Truth(UO.GetGumpsCount() > 0))
        {
            UO.SelectGump(0);
            UO.Print(UO.LastGump("gumpid"));
        }

        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.SelectGump(id) — UO.SelectGump(Any)

Paramètres: id (Any)

Résultat: void / Unit.

Pendant un appel:

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

public void SelectGump(InjectionValue id) => bridge.SelectGump(NumberConversions.ToInt(id));

UO.SendGumpSelect

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

Signatures C#

int UO.SendGumpSelect(object? triggerId);
int UO.SendGumpSelect(object? gumpIndex, object? triggerId);
int UO.SendGumpSelect(object? serial, object? gumpId, object? triggerId);
int UO.SendGumpSelect(object? serial, object? gumpId, object? triggerId, object? timeout);

Envoie le ButtonID pour le serveur sélectionné.

Paramètres

  • triggerId - int ou chaîne numérique - Server ButtonID. 0 signifie généralement fermer/refuser, mais l'action exacte est déterminée par le serveur. Un ButtonID visible dans l’arborescence n’est pas requis.
  • gumpIndex — Obligatoire int — index du serveur Gump actif, de 0 à GetGumpsCount()-1. Ce n'est pas 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 ; vérifiez GetGumpID/GetGumpSerial avant d'agir. Utilisé uniquement sous forme de deux arguments (gumpIndex, triggerId).
  • serial — Dans les formes d'argument 3/4, le bit numérique 32 serial. 0 ou -1 désactive le filtre serial ; les nombres restants, y compris les nombres négatifs avec le bit le plus significatif, sont comparés exactement.
  • gumpId — Dans les formulaires d'argument 3/4, le GumpID numérique 32-bit. 0 ou -1 désactive le filtre GumpID. Les chaînes hexadécimales sont autorisées ; les noms AddObject ne sont pas autorisés ici.
  • timeout — Quatrième argument facultatif, int millisecondes pour attendre une paire ID correspondante. Par défaut, 0 est une tentative immédiate ; le négatif est limité à 0. Revérifiez l'intervalle 20 ms.

Valeur de retour

int — 1, si un serveur en direct est trouvé et que la réponse est appelée ; 0 si la fenêtre n'est pas trouvée avant l'expiration du délai d'attente. Ne renvoie pas le ID sélectionné et n'attend pas que le serveur confirme le résultat.

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 argument sélectionne le gump précédemment sélectionné par ce script ; s'il est fermé/non sélectionné - le dernier élément de la liste actuelle. Deux arguments spécifient un index strict. Trois/quatre - une paire de ID avec filtres.
  • La sélection et l'appel d'une réponse se produisent dans une seule demande de fil de jeu. L'attente est annulée par l'arrêt de la procédure. Ne confondez pas réponse directe du serveur avec changement de page : le bouton SwitchPage nécessite NumGumpButton.

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

1. Répondre à la fenêtre sélectionnée - script direct

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

  • SelectGump sélectionne le type/serial 0x12345678 ou signale l'absence ; 100 - ID du bouton.
  • S'il n'y a plus de fenêtre sélectionnée, le formulaire à un argument utilise la dernière fenêtre disponible. Pour une identité stricte, utilisez un formulaire avec deux ID.
UO.SelectGump(0x12345678);
var sent = UO.SendGumpSelect(100);
UO.Print(Convert.ToString(sent));

2. Répondre au premier élément de la liste - fonction de script

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

  • 0 — index, 100 — ButtonID. Ce n'est pas serial=0 ni GumpID=100.
return  RunScenario();
 object? RunScenario()
{
    var sent = UO.SendGumpSelect(0, 100);
    if (Truth(sent == 0))
    {
        UO.Print("No gump at index zero");
    }

    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. Répondre spécifiquement à la fenêtre à partir de l'instantané - classe de script

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

  • info[0] - serial, info[1] - GumpID, 100 - ButtonID. La modification de l'index ne redirigera pas la réponse vers un autre type/propriétaire.
  • Les valeurs Serial/GumpID 0/-1 sont des filtres sans contrainte ; les paires identiques ne distinguent pas les instances rouvertes.
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))
        {
            var sent = UO.SendGumpSelect(info[0], info[1], 100);
        }

        return null;
    }

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

4. Attendez-vous à un type spécifique - script direct

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

  • 0 désactive le filtre serial ; 0x87654321 — exacte ID avec le bit le plus significatif ; 100 — bouton ; 2000 — attente maximale en ms. Non utilisé comme caractère générique inconditionnel.
var sent = UO.SendGumpSelect(0, 0x87654321, 100, 2000);
UO.Print(Convert.ToString(sent));

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.SendGumpSelect(triggerId) — UO.SendGumpSelect(Integer)

Paramètres: triggerId (Integer/String)

Résultat: int / Integer.

Pendant un appel:

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

public int SendGumpSelect(int triggerId) => bridge.SendGumpSelect(triggerId);

UO.SendGumpSelect(triggerId) — UO.SendGumpSelect(String)

Paramètres: triggerId (Integer/String)

Résultat: int / Integer.

Pendant un appel:

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

public int SendGumpSelect(string triggerId) => SendGumpSelect(NumberConversions.ToInt(triggerId));

UO.SendGumpSelect(gumpIndex, triggerId) — UO.SendGumpSelect(Any,Any)

Paramètres: gumpIndex (Any), triggerId (Any)

Résultat: int / Integer.

Pendant un appel:

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

public int SendGumpSelect(InjectionValue gumpIndex, InjectionValue triggerId)

            => bridge.SendGumpSelect(NumberConversions.ToInt(gumpIndex), NumberConversions.ToInt(triggerId));

UO.SendGumpSelect(serial, gumpId, triggerId) — UO.SendGumpSelect(Any,Any,Any)

Paramètres: serial (Any), gumpId (Any), triggerId (Any)

Résultat: int / Integer.

Pendant un appel:

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

public int SendGumpSelect(InjectionValue serial, InjectionValue gumpId, InjectionValue triggerId)

            => bridge.SendGumpSelect(NumberConversions.ToInt(serial), NumberConversions.ToInt(gumpId), NumberConversions.ToInt(triggerId));

UO.SendGumpSelect(serial, gumpId, triggerId, timeout) — UO.SendGumpSelect(Any,Any,Any,Any)

Paramètres: serial (Any), gumpId (Any), triggerId (Any), timeout (Any)

Résultat: int / Integer.

Pendant un appel:

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

public int SendGumpSelect(InjectionValue serial, InjectionValue gumpId, InjectionValue triggerId, InjectionValue timeout)

            => bridge.SendGumpSelect(NumberConversions.ToInt(serial), NumberConversions.ToInt(gumpId),

                NumberConversions.ToInt(triggerId), Math.Max(0, NumberConversions.ToInt(timeout)));

UO.SetGump

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

Signatures C#

void UO.SetGump(object? identifier, object? key, object? stateValue);
void UO.SetGump(object? gumpId, object? identifier, object? key, object? stateValue);

Modifie le champ d'un serveur Gump existant.

Paramètres

  • gumpId - Forme à quatre arguments uniquement : serial/id ou index Gump nul. Le formulaire à trois utilise -1 - le dernier gum sélectionné.
  • identifier — Chaîne "checkbox", "radio" ou "textentry", la casse n'est pas importante. Un nom non pris en charge ne modifie pas le champ.
  • key - int : premier élément LocalSerial/ID, puis index zéro parmi les éléments du type spécifié. Aucun élément - message d'erreur.
  • stateValue — Pour case à cocher/radio : "coché", "true" insensible à la casse ou non reconnu par zéro int inclut ; l'autre s'éteint. Pour la saisie de texte - tout le texte via ToString.

Valeur de retour

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

Comportement

  • SetGumpValue appelle TrySetGumpValue ; avec 0 affiche un message. Modifie le champ local d'un gump déjà existant et n'enregistre pas de hook en attente d'une nouvelle fenêtre.
  • Changer la case à cocher/l'entrée de texte n'envoie pas de réponse au serveur par lui-même. Pour répondre, sélectionnez le bouton via SendGumpSelect/WaitGump ; Les boutons radio sont traités dans une vue séparée.

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.SetGump");
UO.SetGump("checkbox", 0, 1);

1. Appel direct - script direct

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

  • Modifie le champ d'un serveur Gump existant.
if (Truth(UO.GetGumpsCount() > 0))
{
    UO.SetGump("checkbox", 0, 1);
}

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

2. Option explicite - fonction de script

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

  • SetGumpValue appelle TrySetGumpValue ; avec 0 affiche un message. Modifie le champ local d'un gump déjà existant et n'enregistre pas de hook en attente d'une nouvelle fenêtre.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.GetGumpsCount() > 0))
    {
        UO.SetGump(0, "textentry", 0, "Example");
    }

    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 :

  • Changer la case à cocher/l'entrée de texte n'envoie pas de réponse au serveur par lui-même. Pour répondre, sélectionnez le bouton via SendGumpSelect/WaitGump ; Les boutons radio sont traités dans une vue séparée.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        if (Truth(UO.GetGumpsCount() > 0))
        {
            UO.SetGump("radio", 0, "true");
            UO.SetGump("checkbox", 0, 0);
        }

        return null;
    }

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

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.SetGump(identifier, key, stateValue) — UO.SetGump(Any,Any,Any)

Paramètres: identifier (Any), key (Any), stateValue (Any)

Résultat: void / Unit.

Pendant un appel:

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

public void SetGump(InjectionValue identifier, InjectionValue key, InjectionValue stateValue)

            => bridge.SetGumpValue(-1, identifier.ToString(), NumberConversions.ToInt(key), stateValue.ToString());

UO.SetGump(gumpId, identifier, key, stateValue) — UO.SetGump(Any,Any,Any,Any)

Paramètres: gumpId (Any), identifier (Any), key (Any), stateValue (Any)

Résultat: void / Unit.

Pendant un appel:

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

public void SetGump(InjectionValue gumpId, InjectionValue identifier, InjectionValue key, InjectionValue stateValue)

            => bridge.SetGumpValue(NumberConversions.ToInt(gumpId), identifier.ToString(), NumberConversions.ToInt(key), stateValue.ToString());

UO.WaitGump

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

Signatures C#

void UO.WaitGump(object? value);
void UO.WaitGump(object? trigger1, object? trigger2);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6, object? trigger7);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6, object? trigger7, object? trigger8);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6, object? trigger7, object? trigger8, object? trigger9);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6, object? trigger7, object? trigger8, object? trigger9, object? trigger10);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6, object? trigger7, object? trigger8, object? trigger9, object? trigger10, object? trigger11);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6, object? trigger7, object? trigger8, object? trigger9, object? trigger10, object? trigger11, object? trigger12);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6, object? trigger7, object? trigger8, object? trigger9, object? trigger10, object? trigger11, object? trigger12, object? trigger13);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6, object? trigger7, object? trigger8, object? trigger9, object? trigger10, object? trigger11, object? trigger12, object? trigger13, object? trigger14);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6, object? trigger7, object? trigger8, object? trigger9, object? trigger10, object? trigger11, object? trigger12, object? trigger13, object? trigger14, object? trigger15);
void UO.WaitGump(object? trigger1, object? trigger2, object? trigger3, object? trigger4, object? trigger5, object? trigger6, object? trigger7, object? trigger8, object? trigger9, object? trigger10, object? trigger11, object? trigger12, object? trigger13, object? trigger14, object? trigger15, object? trigger16);

Enregistre une séquence de réponses uniques aux boutons. Le script continue de s'exécuter immédiatement ; l'absence de fenêtre n'entraîne pas de délai de 30-seconde.

Paramètres

  • value — Élément de séquence : int ButtonID, numérique string, chaîne avec |/virgule ou tableau de tels éléments. L'ordre est de gauche à droite. Les limites générales et les règles triggerId s'appliquent. Value est le nom du seul paramètre de la forme object?, qui accepte également un tableau.
  • trigger1 — Élément de séquence : int ButtonID, numérique string, chaîne avec |/virgule ou tableau de tels éléments. L'ordre est de gauche à droite. Les limites générales et les règles triggerId s'appliquent. Value est le nom du seul paramètre de la forme object?, qui accepte également un tableau.
  • trigger2 — Élément de séquence : int ButtonID, numérique string, chaîne avec |/virgule ou tableau de tels éléments. L'ordre est de gauche à droite. Les limites générales et les règles triggerId s'appliquent. Value est le nom du seul paramètre de la forme object?, qui accepte également un tableau.
  • trigger3 — Élément de séquence : int ButtonID, numérique string, chaîne avec |/virgule ou tableau de tels éléments. L'ordre est de gauche à droite. Les limites générales et les règles triggerId s'appliquent. Value est le nom du seul paramètre de la forme object?, qui accepte également un tableau.
  • trigger4 — Élément de séquence : int ButtonID, numérique string, chaîne avec |/virgule ou tableau de tels éléments. L'ordre est de gauche à droite. Les limites générales et les règles triggerId s'appliquent. Value est le nom du seul paramètre de la forme object?, qui accepte également un tableau.
  • trigger5 — Élément de séquence : int ButtonID, numérique string, chaîne avec |/virgule ou tableau de tels éléments. L'ordre est de gauche à droite. Les limites générales et les règles triggerId s'appliquent. Value est le nom du seul paramètre de la forme object?, qui accepte également un tableau.
  • trigger6 — Élément de séquence : int ButtonID, numérique string, chaîne avec |/virgule ou tableau de tels éléments. L'ordre est de gauche à droite. Les limites générales et les règles triggerId s'appliquent. Value est le nom du seul paramètre de la forme object?, qui accepte également un tableau.
  • trigger7 — Élément de séquence : int ButtonID, numérique string, chaîne avec |/virgule ou tableau de tels éléments. L'ordre est de gauche à droite. Les limites générales et les règles triggerId s'appliquent. Value est le nom du seul paramètre de la forme object?, qui accepte également un tableau.
  • trigger8 — Élément de séquence : int ButtonID, numérique string, chaîne avec |/virgule ou tableau de tels éléments. L'ordre est de gauche à droite. Les limites générales et les règles triggerId s'appliquent. Value est le nom du seul paramètre de la forme object?, qui accepte également un tableau.
  • trigger9 — Élément de séquence : int ButtonID, numérique string, chaîne avec |/virgule ou tableau de tels éléments. L'ordre est de gauche à droite. Les limites générales et les règles triggerId s'appliquent. Value est le nom du seul paramètre de la forme object?, qui accepte également un tableau.
  • trigger10 — Élément de séquence : int ButtonID, numérique string, chaîne avec |/virgule ou tableau de tels éléments. L'ordre est de gauche à droite. Les limites générales et les règles triggerId s'appliquent. Value est le nom du seul paramètre de la forme object?, qui accepte également un tableau.
  • trigger11 — Élément de séquence : int ButtonID, numérique string, chaîne avec |/virgule ou tableau de tels éléments. L'ordre est de gauche à droite. Les limites générales et les règles triggerId s'appliquent. Value est le nom du seul paramètre de la forme object?, qui accepte également un tableau.
  • trigger12 — Élément de séquence : int ButtonID, numérique string, chaîne avec |/virgule ou tableau de tels éléments. L'ordre est de gauche à droite. Les limites générales et les règles triggerId s'appliquent. Value est le nom du seul paramètre de la forme object?, qui accepte également un tableau.
  • trigger13 — Élément de séquence : int ButtonID, numérique string, chaîne avec |/virgule ou tableau de tels éléments. L'ordre est de gauche à droite. Les limites générales et les règles triggerId s'appliquent. Value est le nom du seul paramètre de la forme object?, qui accepte également un tableau.
  • trigger14 — Élément de séquence : int ButtonID, numérique string, chaîne avec |/virgule ou tableau de tels éléments. L'ordre est de gauche à droite. Les limites générales et les règles triggerId s'appliquent. Value est le nom du seul paramètre de la forme object?, qui accepte également un tableau.
  • trigger15 — Élément de séquence : int ButtonID, numérique string, chaîne avec |/virgule ou tableau de tels éléments. L'ordre est de gauche à droite. Les limites générales et les règles triggerId s'appliquent. Value est le nom du seul paramètre de la forme object?, qui accepte également un tableau.
  • trigger16 — Élément de séquence : int ButtonID, numérique string, chaîne avec |/virgule ou tableau de tels éléments. L'ordre est de gauche à droite. Les limites générales et les règles triggerId s'appliquent. Value est le nom du seul paramètre de la forme object?, qui accepte également un tableau.

Valeur de retour

void - ne renvoie rien : ni succès, ni nouvelle valeur, ni confirmation du serveur.

Comportement

  • Recherche un véritable bouton d'activation avec le ButtonID souhaité ; Les boutons permettant de changer de page et de fenêtre sans le bouton requis sont ignorés. Les ID suivants ne contournent pas le premier en attente. Pour une livraison de balisage - pas plus d'une réponse dans une fenêtre. Le balisage mis à jour peut utiliser le même objet window.
  • Le prochain WaitGump du même script termine sa séquence en attente. La recherche ne se limite pas à GumpID : utilisez NumGumpButton ou SendGumpSelect pour une sélection précise. ButtonID=0 ne fonctionnera que s'il existe un bouton d'activation existant avec ID 0 ; Ce n’est pas une fermeture universelle.
  • L'achèvement normal de la procédure évite l'attente. Annuler le propriétaire ou Terminate avec son nom supprime ses attentes ; TerminateAll supprime tout, y compris ceux qui restent après la fin des procédures. Changer le monde libère la file d’attente. Les attentes ne sont pas enregistrées dans le profil.

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

1. Une réponse - script direct

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

  • 100 — ButtonID de la réponse. WaitGump l'enregistre avant UseObject ; la poursuite de l'exécution ne signifie pas que le serveur a déjà accepté la réponse.
UO.WaitGump(100);
UO.UseObject("0x40001234");

2. Plusieurs étapes - Fonction de script

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

  • 7, 22 et 1 sont les ButtonID des formulaires séquentiels. Ces ID sont vérifiés dans l'ordre. Le nombre d'arguments ne précise pas le délai ; l'appel enregistre toute la séquence.
return  RunScenario();
 object? RunScenario()
{
    UO.WaitGump(7, 22, 1);
    UO.UseObject("0x40001234");
    return null;
}

3. Annuler les attentes - Classe de script

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

  • La ligne 7|22|1 spécifie la même séquence. TerminateAll efface ensuite toutes les gommes en attente et arrête toutes les procédures ; c'est une action mondiale.
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.WaitGump("7|22|1");
        UO.TerminateAll();
        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.WaitGump(value) — UO.WaitGump(Any)

Paramètres: value (Any/Integer/String)

Résultat: void / Unit.

Pendant un appel:

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

case "waitgump": CompactWaitGump(arguments); return InjectionValue.Unit;

UO.WaitGump(value) — UO.WaitGump(Integer)

Paramètres: value (Any/Integer/String)

Résultat: void / Unit.

Pendant un appel:

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

public void WaitGump(int triggerId)

        {

            if (bridge is IApiGumpAutomation automation) automation.QueueGumpButtons(new[] { triggerId });

            else bridge.WaitGumpSelect(triggerId, 30_000);

        }

UO.WaitGump(value) — UO.WaitGump(String)

Paramètres: value (Any/Integer/String)

Résultat: void / Unit.

Pendant un appel:

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

public void WaitGump(string triggerId)

        {

            string text = (triggerId ?? string.Empty).Trim();

            if (text.Contains('|') || text.Contains(','))

            {

                InjectionValue[] chain = text.Split(new[] { '|', ',' }, StringSplitOptions.RemoveEmptyEntries)

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

                CompactWaitGump(chain);

                return;

            }

            WaitGump(NumberConversions.ToInt(triggerId));

        }

UO.WaitGump(trigger1, trigger2) — UO.WaitGump(Any,Any)

Paramètres: trigger1 (Any), trigger2 (Any)

Résultat: void / Unit.

Pendant un appel:

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

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

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

UO.WaitGump(trigger1, trigger2, trigger3) — UO.WaitGump(Any,Any,Any)

Paramètres: trigger1 (Any), trigger2 (Any), trigger3 (Any)

Résultat: void / Unit.

Pendant un appel:

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

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

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

UO.WaitGump(trigger1, trigger2, trigger3, trigger4) — UO.WaitGump(Any,Any,Any,Any)

Paramètres: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any)

Résultat: void / Unit.

Pendant un appel:

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

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

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5) — UO.WaitGump(Any,Any,Any,Any,Any)

Paramètres: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any), trigger5 (Any)

Résultat: void / Unit.

Pendant un appel:

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

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

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6) — UO.WaitGump(Any,Any,Any,Any,Any,Any)

Paramètres: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any), trigger5 (Any), trigger6 (Any)

Résultat: void / Unit.

Pendant un appel:

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

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

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6, trigger7) — UO.WaitGump(Any,Any,Any,Any,Any,Any,Any)

Paramètres: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any), trigger5 (Any), trigger6 (Any), trigger7 (Any)

Résultat: void / Unit.

Pendant un appel:

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

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

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6, trigger7, trigger8) — UO.WaitGump(Any,Any,Any,Any,Any,Any,Any,Any)

Paramètres: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any), trigger5 (Any), trigger6 (Any), trigger7 (Any), trigger8 (Any)

Résultat: void / Unit.

Pendant un appel:

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

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

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6, trigger7, trigger8, trigger9) — UO.WaitGump(Any,Any,Any,Any,Any,Any,Any,Any,Any)

Paramètres: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any), trigger5 (Any), trigger6 (Any), trigger7 (Any), trigger8 (Any), trigger9 (Any)

Résultat: void / Unit.

Pendant un appel:

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

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

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6, trigger7, trigger8, trigger9, trigger10) — UO.WaitGump(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)

Paramètres: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any), trigger5 (Any), trigger6 (Any), trigger7 (Any), trigger8 (Any), trigger9 (Any), trigger10 (Any)

Résultat: void / Unit.

Pendant un appel:

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

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

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6, trigger7, trigger8, trigger9, trigger10, trigger11) — UO.WaitGump(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)

Paramètres: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any), trigger5 (Any), trigger6 (Any), trigger7 (Any), trigger8 (Any), trigger9 (Any), trigger10 (Any), trigger11 (Any)

Résultat: void / Unit.

Pendant un appel:

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

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

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6, trigger7, trigger8, trigger9, trigger10, trigger11, trigger12) — UO.WaitGump(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)

Paramètres: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any), trigger5 (Any), trigger6 (Any), trigger7 (Any), trigger8 (Any), trigger9 (Any), trigger10 (Any), trigger11 (Any), trigger12 (Any)

Résultat: void / Unit.

Pendant un appel:

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

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

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6, trigger7, trigger8, trigger9, trigger10, trigger11, trigger12, trigger13) — UO.WaitGump(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)

Paramètres: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any), trigger5 (Any), trigger6 (Any), trigger7 (Any), trigger8 (Any), trigger9 (Any), trigger10 (Any), trigger11 (Any), trigger12 (Any), trigger13 (Any)

Résultat: void / Unit.

Pendant un appel:

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

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

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6, trigger7, trigger8, trigger9, trigger10, trigger11, trigger12, trigger13, trigger14) — UO.WaitGump(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)

Paramètres: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any), trigger5 (Any), trigger6 (Any), trigger7 (Any), trigger8 (Any), trigger9 (Any), trigger10 (Any), trigger11 (Any), trigger12 (Any), trigger13 (Any), trigger14 (Any)

Résultat: void / Unit.

Pendant un appel:

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

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

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6, trigger7, trigger8, trigger9, trigger10, trigger11, trigger12, trigger13, trigger14, trigger15) — UO.WaitGump(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)

Paramètres: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any), trigger5 (Any), trigger6 (Any), trigger7 (Any), trigger8 (Any), trigger9 (Any), trigger10 (Any), trigger11 (Any), trigger12 (Any), trigger13 (Any), trigger14 (Any), trigger15 (Any)

Résultat: void / Unit.

Pendant un appel:

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

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

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

UO.WaitGump(trigger1, trigger2, trigger3, trigger4, trigger5, trigger6, trigger7, trigger8, trigger9, trigger10, trigger11, trigger12, trigger13, trigger14, trigger15, trigger16) — UO.WaitGump(Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any,Any)

Paramètres: trigger1 (Any), trigger2 (Any), trigger3 (Any), trigger4 (Any), trigger5 (Any), trigger6 (Any), trigger7 (Any), trigger8 (Any), trigger9 (Any), trigger10 (Any), trigger11 (Any), trigger12 (Any), trigger13 (Any), trigger14 (Any), trigger15 (Any), trigger16 (Any)

Résultat: void / Unit.

Pendant un appel:

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

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

values =>

                    {

                        CompactWaitGump(values);

                        return InjectionValue.Unit;

                    }

UO.WaitGumpCheck

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

Signatures C#

void UO.WaitGumpCheck(object? index, object? state);
void UO.WaitGumpCheck(object? index, object? state, object? index2, object? state2);
void UO.WaitGumpCheck(object? index, object? state, object? index2, object? state2, object? index3, object? state3);

Modifie jusqu'à trois champs de case à cocher du Gump actuel.

Paramètres

  • index — élément int ID ou indice zéro, comme SetGump. Les arguments viennent par paires : sélecteur, valeur.
  • index2 — élément int ID ou indice zéro, comme SetGump. Les arguments viennent par paires : sélecteur, valeur.
  • index3 — élément int ID ou indice zéro, comme SetGump. Les arguments viennent par paires : sélecteur, valeur.
  • state — Valeur du champ via ToString. La case à cocher inclut « coché »/"true"/un nombre non nul ; textentry accepte le texte.
  • state2 — Valeur du champ via ToString. La case à cocher inclut « coché »/"true"/un nombre non nul ; textentry accepte le texte.
  • state3 — Valeur du champ via ToString. La case à cocher inclut « coché »/"true"/un nombre non nul ; textentry accepte le texte.

Valeur de retour

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

Comportement

  • ExecuteLegacyManualAlias parcourt les arguments par paires et appelle SetGumpValue(-1, "checkbox", sélecteur, valeur) pour chacun. Tous les formulaires enregistrés sont des arguments 2, 4 ou 6.
  • Le nom UO.Wait ne signifie pas attendre : il n'y a pas de blocage ni de file d'attente pour un futur gump. Si le champ est manquant, une erreur s'affiche. La réponse du bouton n'est pas envoyée.

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

1. Appel direct - script direct

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

  • Modifie jusqu'à trois champs de case à cocher du Gump actuel.
if (Truth(UO.GetGumpsCount() > 0))
{
    UO.WaitGumpCheck(0, 1);
}

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

2. Option explicite - fonction de script

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

  • ExecuteLegacyManualAlias parcourt les arguments par paires et appelle SetGumpValue(-1, "checkbox", sélecteur, valeur) pour chacun. Tous les formulaires enregistrés sont des arguments 2, 4 ou 6.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.GetGumpsCount() > 0))
    {
        UO.WaitGumpCheck(0, 1, 1, 0);
    }

    return null;
}

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

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

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

  • Le nom UO.Wait ne signifie pas attendre : il n'y a pas de blocage ni de file d'attente pour un futur gump. Si le champ est manquant, une erreur s'affiche. La réponse du bouton n'est pas envoyée.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        if (Truth(UO.GetGumpsCount() > 0))
        {
            UO.WaitGumpCheck(0, 1, 1, 0, 2, 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;
}

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.WaitGumpCheck(index, state) — UO.WaitGumpCheck(Any,Any)

Paramètres: index (Any), state (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "waitgumpcheck":

                    for (int index = 0; index + 1 < arguments.Length; index += 2)

                        bridge.SetGumpValue(-1, "checkbox", Arg(index), Text(index + 1));

                    break;

UO.WaitGumpCheck(index, state, index2, state2) — UO.WaitGumpCheck(Any,Any,Any,Any)

Paramètres: index (Any), state (Any), index2 (Any), state2 (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "waitgumpcheck":

                    for (int index = 0; index + 1 < arguments.Length; index += 2)

                        bridge.SetGumpValue(-1, "checkbox", Arg(index), Text(index + 1));

                    break;

UO.WaitGumpCheck(index, state, index2, state2, index3, state3) — UO.WaitGumpCheck(Any,Any,Any,Any,Any,Any)

Paramètres: index (Any), state (Any), index2 (Any), state2 (Any), index3 (Any), state3 (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "waitgumpcheck":

                    for (int index = 0; index + 1 < arguments.Length; index += 2)

                        bridge.SetGumpValue(-1, "checkbox", Arg(index), Text(index + 1));

                    break;

UO.WaitGumpEntry

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

Signatures C#

void UO.WaitGumpEntry(object? index, object? text);
void UO.WaitGumpEntry(object? index, object? text, object? index2, object? text2);
void UO.WaitGumpEntry(object? index, object? text, object? index2, object? text2, object? index3, object? text3);

Modifie jusqu'à trois champs de saisie de texte du Gump actuel.

Paramètres

  • index — élément int ID ou indice zéro, comme SetGump. Les arguments viennent par paires : sélecteur, valeur.
  • index2 — élément int ID ou indice zéro, comme SetGump. Les arguments viennent par paires : sélecteur, valeur.
  • index3 — élément int ID ou indice zéro, comme SetGump. Les arguments viennent par paires : sélecteur, valeur.
  • text — Valeur du champ via ToString. La case à cocher inclut « coché »/"true"/un nombre non nul ; textentry accepte le texte.
  • text2 — Valeur du champ via ToString. La case à cocher inclut « coché »/"true"/un nombre non nul ; textentry accepte le texte.
  • text3 — Valeur du champ via ToString. La case à cocher inclut « coché »/"true"/un nombre non nul ; textentry accepte le texte.

Valeur de retour

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

Comportement

  • ExecuteLegacyManualAlias parcourt les arguments par paires et appelle SetGumpValue(-1, "textentry", sélecteur, valeur) pour chacun. Tous les formulaires enregistrés sont des arguments 2, 4 ou 6.
  • Le nom UO.Wait ne signifie pas attendre : il n'y a pas de blocage ni de file d'attente pour un futur gump. Si le champ est manquant, une erreur s'affiche. La réponse du bouton n'est pas envoyée.

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

1. Appel direct - script direct

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

  • Modifie jusqu'à trois champs de saisie de texte du Gump actuel.
if (Truth(UO.GetGumpsCount() > 0))
{
    UO.WaitGumpEntry(0, "Example");
}

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

2. Option explicite - fonction de script

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

  • ExecuteLegacyManualAlias parcourt les arguments par paires et appelle SetGumpValue(-1, "textentry", sélecteur, valeur) pour chacun. Tous les formulaires enregistrés sont des arguments 2, 4 ou 6.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.GetGumpsCount() > 0))
    {
        UO.WaitGumpEntry(0, "First", 1, "Second");
    }

    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 :

  • Le nom UO.Wait ne signifie pas attendre : il n'y a pas de blocage ni de file d'attente pour un futur gump. Si le champ est manquant, une erreur s'affiche. La réponse du bouton n'est pas envoyée.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        if (Truth(UO.GetGumpsCount() > 0))
        {
            UO.WaitGumpEntry(0, "First", 1, "Second", 2, "Third");
        }

        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.WaitGumpEntry(index, text) — UO.WaitGumpEntry(Any,Any)

Paramètres: index (Any), text (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "waitgumpentry":

                    for (int index = 0; index + 1 < arguments.Length; index += 2)

                        bridge.SetGumpValue(-1, "textentry", Arg(index), Text(index + 1));

                    break;

UO.WaitGumpEntry(index, text, index2, text2) — UO.WaitGumpEntry(Any,Any,Any,Any)

Paramètres: index (Any), text (Any), index2 (Any), text2 (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "waitgumpentry":

                    for (int index = 0; index + 1 < arguments.Length; index += 2)

                        bridge.SetGumpValue(-1, "textentry", Arg(index), Text(index + 1));

                    break;

UO.WaitGumpEntry(index, text, index2, text2, index3, text3) — UO.WaitGumpEntry(Any,Any,Any,Any,Any,Any)

Paramètres: index (Any), text (Any), index2 (Any), text2 (Any), index3 (Any), text3 (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "waitgumpentry":

                    for (int index = 0; index + 1 < arguments.Length; index += 2)

                        bridge.SetGumpValue(-1, "textentry", Arg(index), Text(index + 1));

                    break;

ClassicUO — Bad Newbie & C# Scripts IDE

ClassicUO — Bad Newbie & C# Scripts IDE

Clone this wiki locally