Skip to content

FR UO Topic items

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

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

Objets

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

Propriétés, utilisation et transfert des objets. Serial sélectionne un élément spécifique ; type/graphic sélectionne la vue. Le transfert d'unités de pile et le nombre d'éléments transférés ont des paramètres différents.

Sections

Sujet Commandes et explications
Item Properties UO.GetSerial · UO.GetType · UO.GetGraphic · UO.GetColor · UO.GetQuantity · UO.GetName · UO.GetTooltip · UO.ContainerOf · UO.GetParent · UO.GetLayer · UO.IsMovable · UO.GetX · UO.GetY · UO.GetZ
Trouver des objets UO.FindType · UO.FindTypeEx · UO.FindTypesArrayEx · UO.FindItem · UO.FindAnyType · UO.FindAtCoord · UO.FindList · UO.FindDistance · UO.FindVertical
Utiliser des éléments UO.UseObject · UO.UseType · UO.UseFromGround · UO.UseWorldObject · UO.UseItemOnMobile
Moving Articles UO.Grab · UO.Drag · UO.Drop · UO.MoveItem · UO.MoveItems · UO.MassMove · UO.EmptyContainer
Ground Articles UO.GetWorldItems · UO.FindType · UO.CountGround · UO.MoveItem
Articles de conteneur UO.GetContent · UO.FindTypeEx · UO.OpenContainer
Articles contrefaits/clients UO.MakeFakeItem · UO.DeleteObject
Dye UO.Dye

Toutes les commandes du thème

Propriétés de l'élément

UO.Exists · UO.IsObjectExists · UO.GetSerial · UO.GetType · UO.GetGraphic · UO.GetColor · UO.GetQuantity · UO.Name · UO.GetName · UO.GetAltName · UO.GetTooltip · UO.GetTooltipRec · UO.GetLayer · UO.GetLocked · UO.IsMovable · UO.GetFlags · UO.ReceiveObjectName · UO.UpdateObject

Utiliser des objets

UO.UseObject · UO.UseType · UO.UseFromGround · UO.UseWorldObject · UO.UseItemOnMobile · UO.ClickOnObject · UO.TicksUse

Moving Articles

UO.Grab · UO.Drag · UO.DragItem · UO.Drop · UO.DropHere · UO.DropItem · UO.MoveItem · UO.MoveItems · UO.MassMove · UO.EmptyContainer · UO.DropDelay · UO.DropCheckCoord · UO.Picking

Articles contrefaits/clients

UO.MakeFakeItem · UO.DeleteObject

Dye

UO.Dye

Objets stockés

UO.AddObject · UO.AddType · UO.EasyObject · UO.UserObject · UO.LastObject · UO.Forget

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

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

var ok = UO.MoveItem("loot");
UO.Print("Move request: " + Convert.ToString(ok));

UO.MassMove

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

UO.MassMove(350, 0);
UO.Print("Drag one sample item to the destination container");

Parties de la référence

1 · 2

Référence complète des commandes

UO.AddObject

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

Signatures C#

void UO.AddObject(object? name);
void UO.AddObject(object? name, object? objectRawId);

Stocke un objet nommé serial pour une utilisation ultérieure par les scripts. La forme à deux arguments spécifie l'objet immédiatement ; un seul argument déclenche la sélection d'un objet par le curseur.

Paramètres

  • name est un nom non vide sous lequel l'objet sera disponible au moment de l'exécution.
  • objectRawId - serial ou un nom d'objet déjà enregistré. La surcharge à un argument n'accepte pas ce paramètre, mais demande à la place la sélection d'un objet.

Valeur de retour

void. Vérifiez la liaison enregistrée en lisant l'objet par son nom ; l'appel ne renvoie pas serial.

Comportement

  • Étant donné deux arguments, le runtime résout objectRawId et stocke serial sous name. Avec un argument, le client demande une sélection d'objet : l'élément ou mobile est sélectionné, mais pas la cellule de la carte. Avant la sélection, la liaison précédente portant le même nom est supprimée ; l'annulation/la perte du curseur ne le restaure pas.

Scripts C# autonomes

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

Exemple simple

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

La commande forme une instruction séparée. Le message précédent indique le début de l’appel et ne confirme aucune action du serveur.

UO.Print("Calling UO.AddObject");
UO.AddObject("target");

1. Enregistrez serial d'un élément connu sous un nom pratique. - scénario direct

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

  • Enregistrez serial d'un élément connu sous un nom pratique.
UO.AddObject("supplyBox", "0x40012345");

2. Demandez la sélection d'un élément ou d'un mobile avec le curseur et nommez-le cible. - fonction de script

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

  • Demandez la sélection d'un élément ou d'un mobile avec le curseur et nommez-le cible.
return  RunScenario();
 object? RunScenario()
{
    UO.AddObject("target");
    return null;
}

3. Enregistrer à nouveau le nom remplace la liaison par un nouveau serial. - cours de script

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

  • Enregistrer à nouveau le nom remplace la liaison par un nouveau serial.
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 selectedSerial = "0x40012345";
        UO.AddObject("supplyBox", selectedSerial);
        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.AddObject(name) — UO.AddObject(String)

Paramètres: name (String)

Résultat: void / Unit.

Pendant un appel:

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

public void AddObject(string name)

        {

            SystemMessage($"What is {name}");

            bridge.AddObject(name);

        }

UO.AddObject(name, objectRawId) — UO.AddObject(Any,Any)

Paramètres: name (Any), objectRawId (Any)

Résultat: void / Unit.

Pendant un appel:

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

public void AddObject(InjectionValue name, InjectionValue objectRawId) 

            => ObjectChecked(objectRawId, id => AddObject((string)name, id));

UO.AddType

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

Signatures C#

void UO.AddType(object? name);
void UO.AddType(object? name, object? @type);

Stocke un nom convivial pour l'élément ou le type de graphique de corps mobile. Par exemple, après UO.AddType("bandage", 0x0E21), vous pouvez rechercher ou utiliser des bandages via le nom « bandage » sans répéter le chiffre type sur chaque ligne. Il s'agit de définir un nom → Cartographie graphique, de ne pas créer d'élément ni de mémoriser un ID spécifique.

Paramètres

  • name - Chaîne obligatoire entre guillemets - votre nom de type. Les espaces de bord sont supprimés, la casse n'a pas d'importance : "Bandage" et "bandage" forment une seule entrée. Chaîne vide, nom numérique, mot quelconque, caractère | et les caractères de contrôle sont interdits. Il s'agit de la valeur du paramètre, pas d'une nouvelle variable ou d'une commande UO : les appels ultérieurs nécessitent également des guillemets.
  • type - Facultatif int 0..65535 : Graphique/type, tel que 0x0E21 ou 3617. Une chaîne avec un nombre décimal/hexadécimal ou le nom d'un type déjà enregistré est acceptable ; ce dernier copie son numéro actuel, ne crée pas de lien entre les noms. ID de la forme 0x40001001, nombre négatif, fraction et nom inconnu ne sont pas acceptés. S'il n'y a pas d'argument, un curseur de sélection apparaît : cliquez sur l'élément chargé, y compris à l'intérieur du conteneur, ou mobile. Le graphique de l'objet sélectionné est enregistré ; la surface au sol et les carreaux statiques ne conviennent pas.

Valeur de retour

void - aucune valeur de retour. Écrivez sur une ligne séparée, sans résultat var = et sans comparaison avec true/1. La commande ne renvoie pas l'indicateur type, serial ou de réussite sélectionné. Lors de l'annulation avec la souris, l'ancienne entrée est conservée ; s'il n'y avait pas de nom auparavant, il reste indéfini. La ligne suivante du script s'exécute après une annulation normale, donc ne déclenchez pas automatiquement l'action en supposant que l'utilisateur a définitivement sélectionné un nouvel élément.

Comportement

  • La forme AddType(nom, type) stocke le numéro immédiatement, sans curseur et sans action réseau. Une répétition du même nom remplace son type. Une valeur erronée ne détruit pas l'entrée précédente. Le formulaire AddType(nom) est en attente de sélection ; Echap, le remplacement du curseur par une autre action ou une cible inappropriée laisse l'entrée inchangée. L'arrêt forcé du script interrompt l'attente et libère uniquement le curseur qui lui appartient.
  • Les noms de types sont séparés de AddObject : le même mot pourrait représenter type dans FindType et serial dans UseObject. AddType("supply", 0x0E21) ne rend pas en soi UseObject("supply") valide. For a specific item, use AddObject/GetSerial; pour une famille d'items - AddType et paramètre type.
  • Les noms sont résolus dans les paramètres de type FindType (toutes les formes), FindTypeEx, FindTypesArrayEx, FindList, FindNotoriety, GetWorldItems, UseType, UseFromGround, Count, CountGround, CountEx, EquipT, WaitTargetType, WaitTargetGround et WaitTargetObjectType. Dans les masques de types GetMobiles/FindAnyType/WaitTarget vous pouvez combiner des noms via | ou tableau ; les règles de notoriété restent distinctes. Les mots humain/proche et autres filtres FindMobile ne sont pas remplacés.
  • Seul le graphique est enregistré, sans couleur, quantité, conteneur, nom d'élément, calque ou propriétés. Deux éléments du même type de couleurs différentes nécessitent une couleur distincte dans la recherche. L'entrée ne confirme pas que l'élément existe actuellement, qu'il est disponible ou que le serveur autorisera l'action.

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

1. Récupérez une pile d'or trouvée - script direct

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

  • gold_stack - nom ; 0x0EED – Or graphique. FindType : -1 - n'importe quelle couleur, ground - terre, 2 - rayon de recherche. La chaîne serial ou une chaîne vide est renvoyée.
  • MoveItem reçoit les serial trouvés, 0 pour la pile entière et backpack comme destination. Il s'agit d'une pile, pas de toutes les piles du rayon. La disponibilité du transfert et le résultat réel dépendent du serveur ; la définition de type elle-même ne contient rien.
UO.AddType("gold_stack", 0x0EED);
var item = UO.FindType("gold_stack", -1, "ground", 2);
if (Truth(item == ""))
{
    UO.Print("No loaded gold stack within 2 tiles");
    return null;
}
var moved = UO.MoveItem(item, 0, "backpack");
if (Truth(moved == 0))
{
    UO.Print("Move request failed");
}

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

2. Utilisez un bandage uniquement lorsque votre santé est faible - fonction de script

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

  • Le numéro de chaîne 0x0E21 est stocké sous int Graphic. Life/MaxHP compare le caractère HP. FindType recherche récursivement n'importe quelle couleur dans le sac à dos ; -1 à distance utilise un comportement de recherche standard.
  • self est le but de l'application, le bandage après FindType est une variable avec serial. La file d'attente de la cible est préparée avant d'utiliser l'élément. Le script envoie l'utilisation et n'affirme pas que le traitement est déjà terminé ; Le minuteur/les règles de traitement dépendent du serveur.
return  RunScenario();
 object? RunScenario()
{
    UO.AddType("bandage", "0x0E21");
    if (Truth(UO.Life() >= UO.MaxHP()))
    {
        return null;
    }

    var bandage = UO.FindType("bandage", -1, "backpack", -1, true);
    if (Truth(bandage == ""))
    {
        UO.Print("No loaded bandages in backpack");
        return null;
    }

    UO.WaitTargetObject("self");
    UO.UseObject(bandage);
    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. Attribuez votre outil à la souris, appliquez-le en tant que procédure distincte - classe de script

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

  • Main ne contient que le nom, donc le curseur s'ouvre. Le type d'outil est enregistré, pas son ID ni sa couleur. UseSavedTool est une procédure autonome normale C#, pas une commande intégrée.
  • UseType recherche une instance d'un type enregistré de n'importe quelle couleur dans le sac à dos et l'utilise ; renvoie int serial ou 0 s'il est manquant. Si le nom n'a jamais été défini, c'est une erreur d'argument, pas le résultat de 0. Après la désaffectation, Main n'appelle pas UseSavedTool.
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.AddType("my_tool");
        return null;
    }

    void UseSavedTool()
    {
        var used = UO.UseType("my_tool", -1, "backpack");
        if (Truth(used == 0))
        {
            UO.Print("No matching loaded tool in backpack");
        }
    }

    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.AddType(name) — UO.AddType(Any)

Paramètres: name (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "addtype":

                    AddType(arguments);

                    break;

UO.AddType(name, type) — UO.AddType(Any,Any)

Paramètres: name (Any), type (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "addtype":

                    AddType(arguments);

                    break;

UO.ClickOnObject

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

Signatures C#

void UO.ClickOnObject(object? objID);

Envoie un simple clic sur un objet via GameActions.SingleClick.

Paramètres

  • objID — Numéro de série de l'objet ou nom pris en charge de l'objet self/backpack/lasttarget/saved ; les chaînes numériques et les chaînes 0x sont résolues par l'exécution.

Valeur de retour

void - aucune valeur de retour.

Comportement

  • Click résout le lien via ObjectChecked. ClickOnObject utilise d'abord Arg pour serial et appelle Click(int). Il s'agit d'une demande de signature/informations sur l'article, et non de DoubleClick ou d'utilisation de l'article. La réponse du serveur arrive de manière asynchrone.

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

1. Cliquez sur le personnage - script direct

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

  • Un simple clic est envoyé à self.
UO.ClickOnObject("self");

2. Cliquez sur la dernière cible - fonction de script

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

  • Avant l'envoi, l'existence locale de la cible est vérifiée.
return  RunScenario();
 object? RunScenario()
{
    var target = UO.LastTarget();
    if (Truth(UO.Exists(target)))
    {
        UO.ClickOnObject(target);
    }

    return null;
}

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

3. Ils cliqueront sur le sac à dos - classe de script

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

  • Un simple clic sur un sac à dos ne l'ouvre pas comme un double-clic dessus.
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 bag = UO.Backpack();
        if (Truth(bag != 0))
        {
            UO.ClickOnObject(bag);
        }

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

Paramètres: objID (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "clickonobject": Click(Arg(0)); return InjectionValue.Unit;

UO.DeleteObject

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

Signatures C#

void UO.DeleteObject(object? name);

Supprime le nom de l'objet stocké de la table d'exécution.

Paramètres

  • name - Nom string dans la table Objets ; Seule cette entrée est supprimée.

Valeur de retour

void - aucune valeur de retour.

Comportement

  • Lorsqu'un nom est trouvé, supprime l'entrée et imprime une confirmation ; S'il n'y a pas de nom, il imprime le message introuvable. L'objet serveur et son contenu ne sont pas supprimés.

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

1. Supprimer le nom créé - script direct

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

  • Seule la connexion temporaire avec le serial du personnage est supprimée.
UO.AddObject("temporary",UO.Self());
UO.DeleteObject("temporary");

2. Nom manquant – Fonction de script

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

  • Un nom manquant provoque un message de diagnostic.
return  RunScenario();
 object? RunScenario()
{
    UO.DeleteObject("missing-example-name");
    return null;
}

3. Nom du magasin dans la variable - classe de script

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

  • La variable string spécifie l'entrée exacte à supprimer.
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 name = "temporary";
        UO.AddObject(name, UO.Self());
        UO.DeleteObject(name);
        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.DeleteObject(name) — UO.DeleteObject(String)

Paramètres: name (String)

Résultat: void / Unit.

Pendant un appel:

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

public void DeleteObject(string name)

        {

            if (objects.TryGet(name, out int value))

            {

                objects.Remove(name);

                SystemMessage($"Object {name} has been deleted");

            }

            else

                SystemMessage($"Object {name} not found");

        }

UO.Drag

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

Signatures C#

int UO.Drag(object? id);
int UO.Drag(object? id, object? amount);
int UO.Drag(object? id, object? amount, object? timeout);
void UO.Drag(object? fromX, object? fromY, object? toX, object? toY);

Élève un élément spécifique au curseur ; un formulaire distinct à quatre arguments fait glisser la souris dans une fenêtre Windows.

Paramètres

  • id — Série d'un élément/caractère spécifique : numéro, chaîne hexadécimale/décimale, self/backpack/lasttarget/lastobject/lastcontainer/lastcorpse/finditem/laststatus ou nom enregistré AddObject. Ce n'est pas type. L'objet doit être chargé ; vérifiez Exists avant d'agir.
  • amount — Nombre d'unités dans une pile. 0 ou une valeur négative signifie la pile entière ; le positif est limité par la quantité disponible. Ce n'est PAS le nombre de stacks qui limite MassMove. S'il est absent, est égal à 0.
  • timeout - Troisième argument facultatif : attendez le Picking observé jusqu'au nombre de millisecondes spécifié ; la valeur par défaut est 0. Une valeur négative équivaut à 0.
  • fromX — Quatre formulaires int uniquement : le X initial de la souris en pixels de la fenêtre client.
  • fromY — Souris initiale Y en pixels de la fenêtre client.
  • toX — La fin X de la souris en pixels.
  • toY — La fin Y de la souris en pixels.

Valeur de retour

Avec les arguments 1..3 int : 1 — la demande de levage a été acceptée par le client (avec timeout>0 un curseur occupé a également été observé) ; 0 — levée rejetée ou délai d'attente expiré. Avec quatre arguments null : aucune valeur de retour. Ce n'est pas un élément ID.

Comportement

  • Pour le transfert de jeu, la forme préférée est id[,amount[,timeout]] suivi de DropItem ou d'un simple MoveItem.
  • Le formulaire fromX/fromY/toX/toY utilise les événements de la souris Windows : déplacer, appuyer, déplacer, relâcher. Il n'y a pas de confirmation du serveur et dépend du contenu/focus réel de la fenêtre.
  • Un curseur occupé n'équivaut pas à un transfert réussi vers la destination. La capture et la libération sont des actions distinctes.

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

1. Ramassez la pile entière et mettez-la dans votre sac à dos - script direct

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

  • butin - serial à AddObject. montant=0 signifie la pile entière ; -1/-1 définit la place automatique dans le gump.
  • DropItem termine la capture du même runtime. La première signifie que la demande a été envoyée, pas la confirmation du serveur.
if (Truth(UO.Drag("loot", 0)))
{
    var dropped = UO.DropItem("backpack", -1, -1, 0);
    UO.Print("Drop request: " + Convert.ToString(dropped));
}

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

2. Participez à la pile avec une attente limitée - fonction de script

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

  • montant=10 — jusqu'à dix unités d'une pile ; timeout=500 ms.
  • 44/55 - coordonnées à l'intérieur du sac à dos, pas sur la carte. Si l'élément ne peut pas être pris, DropItem n'est pas appelé.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Drag("loot", 10, 500)))
    {
        var dropped = UO.DropItem("backpack", 44, 55, 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. Vérifiez les mains occupées avant de saisir - cours de script

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

  • Un argument Drag signifie la pile entière et timeout=0.
  • Picking vérifie le curseur partagé du client. N'exécutez pas deux migrations indépendantes en même temps.
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.Picking() == 0))
        {
            if (Truth(UO.Drag("loot")))
            {
                var dropped = UO.DropItem("backpack", -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;
}

4. Quatre coordonnées de souris - script direct

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

  • Ce sont les pixels de la fenêtre : début (100,120), fin (260,180). Il n'y a pas de serial, de montant ou de délai d'attente.
  • À utiliser uniquement lorsque les éléments requis se trouvent à ces endroits ; Pour les objets, l'adressage par serial est plus fiable.
UO.Drag(100, 120, 260, 180);

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.Drag(id) — UO.Drag(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 Drag(InjectionValue id) => Drag(id, InjectionValue.Zero, InjectionValue.Zero);

UO.Drag(id, amount) — UO.Drag(Any,Any)

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

Résultat: int / Integer.

Pendant un appel:

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

public int Drag(InjectionValue id, InjectionValue amount) => Drag(id, amount, InjectionValue.Zero);

UO.Drag(id, amount, timeout) — UO.Drag(Any,Any,Any)

Paramètres: id (Any), amount (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 Drag(InjectionValue id, InjectionValue amount, InjectionValue timeout)

        {

            int serial = GetObject(id);

            if (serial == 0)

                return 0;

            int requestedAmount = NumberConversions.ToInt(amount);

            int timeoutMs = Math.Max(0, NumberConversions.ToInt(timeout));

            int result = bridge.DragItem(serial, requestedAmount);

            if (result == 0 || timeoutMs <= 0)

                return result;



            DateTime deadline = DateTime.UtcNow.AddMilliseconds(timeoutMs);

            do

            {

                if (bridge.Picking() != 0)

                    return 1;

                if (DateTime.UtcNow >= deadline)

                    break;

                bridge.Wait(10);

            }

            while (true);



            SystemMessage($"UO.Drag: item pickup was not observable within {timeoutMs} ms.");

            return 0;

        }

UO.Drag(fromX, fromY, toX, toY) — UO.Drag(Integer,Integer,Integer,Integer)

Paramètres: fromX (Integer), fromY (Integer), toX (Integer), toY (Integer)

Résultat: void / Unit.

Pendant un appel:

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

public void Drag(int fromX, int fromY, int toX, int toY) => bridge.Drag(fromX, fromY, toX, toY);

UO.DragItem

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

Signatures C#

dynamic UO.DragItem(object? objID, object? count);

Récupère un élément spécifique et s'en souvient pour DropItem ce runtime.

Paramètres

  • objID — Série d'un élément/caractère spécifique : numéro, chaîne hexadécimale/décimale, self/backpack/lasttarget/lastobject/lastcontainer/lastcorpse/finditem/laststatus ou nom enregistré AddObject. Ce n'est pas type. L'objet doit être chargé ; vérifiez Exists avant d'agir.
  • count — Nombre d'unités dans une pile. 0 ou une valeur négative signifie la pile entière ; le positif est limité par la quantité disponible. Ce n'est PAS le nombre de stacks qui limite MassMove.

Valeur de retour

int 1 — le client a accepté la hausse ; 0 - article non trouvé ou PickUp refusé. Métadonnées de compatibilité object ? ne signifie pas un type de résultat arbitraire. Ce n'est pas serial.

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

  • Les deux arguments sont requis. Il n’y a pas d’attente de confirmation intégrée ; le formulaire Drag(id,amount,timeout) ajoute une attente pour le Picking local.
  • Après une capture réussie, terminez l'action DropItem. Un élément récupéré manuellement par la souris ne définit pas la mémoire DragItem de ce runtime.

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

1. Augmenter la pile entière - script direct

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

  • ObjID=loot via AddObject, Count=0 est la pile entière.
  • La deuxième équipe laisse tomber le même objet ramassé.
if (Truth(UO.DragItem("loot", 0)))
{
    var ok = UO.DropItem("backpack", -1, -1, 0);
}

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

2. Augmenter cinq unités - fonction de script

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

  • Remplacez ObjID par votre serial. Count=5 fait référence aux unités de la même pile.
  • L'emplacement 44/55 se trouve à l'intérieur du sac à dos.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.DragItem(0x40001234, 5)))
    {
        var ok = UO.DropItem("backpack", 44, 55, 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. Afficher l'échec de la capture - Classe de script

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

  • picked — int 1/0.
  • N'appelez pas DropItem après un échec de capture : le curseur peut appartenir à une autre activité.
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 picked = UO.DragItem("loot", 0);
        if (Truth(picked == 0))
        {
            UO.Print("Item was not picked up");
        }
        else
        {
            var ok = UO.DropItem("backpack", -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;
}

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.DragItem(objID, count) — UO.DragItem(Any,Any)

Paramètres: objID (Any), count (Any)

Résultat: dynamic / Any.

Pendant un appel:

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

case "dragitem": return new InjectionValue(bridge.DragItem(Arg(0), Arg(1)));

UO.Drop

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

Signatures C#

int UO.Drop(object? @object);
int UO.Drop(object? @object, object? count);
int UO.Drop(object? @object, object? count, object? destination);
dynamic UO.Drop(object? objID, object? count, object? x, object? y, object? z);

Effectue un transfert complet de l'élément spécifié, par défaut au sol sous le personnage.

Paramètres

  • object — Série d'un élément/caractère spécifique : numéro, chaîne hexadécimale/décimale, self/backpack/lasttarget/lastobject/lastcontainer/lastcorpse/finditem/laststatus ou nom enregistré AddObject. Ce n'est pas type. L'objet doit être chargé ; vérifiez Exists avant d'agir.
  • objID — Série d'un élément/caractère spécifique : numéro, chaîne hexadécimale/décimale, self/backpack/lasttarget/lastobject/lastcontainer/lastcorpse/finditem/laststatus ou nom enregistré AddObject. Ce n'est pas type. L'objet doit être chargé ; vérifiez Exists avant d'agir.
  • count — Nombre d'unités dans une pile. 0 ou une valeur négative signifie la pile entière ; le positif est limité par la quantité disponible. Ce n'est PAS le nombre de stacks qui limite MassMove. En abrégé, sans compter, c'est 0.
  • destination - Uniquement sous la forme à trois arguments : Numéro de série du conteneur ou nom de l'ensemble AddObject ; backpack/self/my choisissez un sac à dos, receiving/catchbag - SetCatchBag, et sans lui un sac à dos. lastcontainer/lastobject/lasttarget/lastcorpse/finditem/laststatus sont valides lorsqu'ils sont résolus dans le bon conteneur. ground ou 0 sélectionne explicitement le terrain ; -1—le même sélecteur de sac à dos. Un nom inconnu ou non spécifié provoque une erreur avant que l'élément ne soit capturé. Sans argument de destination, le sac à dos est utilisé.
  • x - Uniquement sous forme de cinq arguments : destination du monde X sur terre.
  • y — Monde Y pour la forme à cinq arguments.
  • z — Hauteur du monde pour la forme à cinq arguments.

Valeur de retour

int 1—demande de transfert complet acceptée par le client ; 0 - échec. La forme compatible à cinq arguments a les métadonnées de object?, mais renvoie en réalité également int 1/0. Il ne s'agit pas d'une réinitialisation du DragItem précédemment pris : utilisez DropItem pour cela.

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

  • Les formulaires avec les arguments 1, 2, 3 et 5 sont enregistrés. Il n’existe pas de formulaire à quatre arguments.
  • Drop(item) transfère la totalité de la pile au sol en dessous ; Drop(item,count) spécifie les unités ; Drop(item,count,destination) autorise le conteneur.
  • Drop(item,count,X,Y,Z) signifie toujours atterrir. Pour un conteneur avec des coordonnées gump, utilisez MoveItem.
  • Des restrictions de levage, DropCheckCoord et de vérification du serveur s'appliquent. L'équipe n'attend pas de confirmation séparée de livraison.

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

1. Toute la pile est sous vos pieds - un script direct

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

  • object=loot via AddObject, count=0 par défaut.
  • Destination - le point actuel du personnage au sol.
var ok = UO.Drop("loot");

2. Cinq unités dans un sac à dos - fonction de script

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

  • count=5 unités d'une pile ; destination=backpack.
  • Le troisième argument ici est un conteneur, pas X.
return  RunScenario();
 object? RunScenario()
{
    var ok = UO.Drop("loot", 5, "backpack");
    return null;
}

3. Point explicite sur le terrain - classe de scénario

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

  • Remplacez ObjID par votre serial ; Count=0 pile entière ; X/Y/Z=1445/1690/0.
  • Pour ce formulaire, la troisième valeur est X. Le Drag préliminaire n'est pas 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()
    {
        var ok = UO.Drop(0x40001234, 0, 1445, 1690, 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.Drop(object) — UO.Drop(Any)

Paramètres: object (Any)

Résultat: int / Integer.

Pendant un appel:

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

case "drop":

                    if (arguments.Length > 0)

                        return new InjectionValue(MoveItem(arguments[0], arguments.Length > 1 ? arguments[1] : InjectionValue.Zero, arguments.Length > 2 ? arguments[2] : new InjectionValue("ground")));

                    return InjectionValue.False;

UO.Drop(object, count) — UO.Drop(Any,Any)

Paramètres: object (Any), count (Any)

Résultat: int / Integer.

Pendant un appel:

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

case "drop":

                    if (arguments.Length > 0)

                        return new InjectionValue(MoveItem(arguments[0], arguments.Length > 1 ? arguments[1] : InjectionValue.Zero, arguments.Length > 2 ? arguments[2] : new InjectionValue("ground")));

                    return InjectionValue.False;

UO.Drop(object, count, destination) — UO.Drop(Any,Any,Any)

Paramètres: object (Any), count (Any), destination (Any)

Résultat: int / Integer.

Pendant un appel:

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

case "drop":

                    if (arguments.Length > 0)

                        return new InjectionValue(MoveItem(arguments[0], arguments.Length > 1 ? arguments[1] : InjectionValue.Zero, arguments.Length > 2 ? arguments[2] : new InjectionValue("ground")));

                    return InjectionValue.False;

UO.Drop(objID, count, x, y, z) — UO.Drop(Any,Any,Any,Any,Any)

Paramètres: objID (Any), count (Any), x (Any), y (Any), z (Any)

Résultat: dynamic / Any.

Pendant un appel:

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

case "drop": return new InjectionValue(MoveItemChecked(Arg(0), Arg(1), 0, Arg(2), Arg(3), Arg(4)) ? 1 : 0);

UO.DropCheckCoord

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

Signatures C#

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

Lit ou modifie la vérification de la plage de coordonnées lors du dépôt d'objets au sol.

Paramètres

  • value — Valeur facultative : 0 désactive, int non nul est activé. Sans argument, l'état est seulement lu.

Valeur de retour

int 0/1 — état actuel après un éventuel enregistrement ; les deux formes renvoient un nombre.

Comportement

  • MoveItemChecked lorsqu'il est attribué à un terrain et que le drapeau est allumé, rejette la distance Chebyshev X/Y supérieure aux cellules 2 du personnage. La vérification ne modifie pas les coordonnées et ne vérifie pas l'autorisation de transfert du serveur. Les affectations de conteneurs ne se limitent pas à cet indicateur.

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

1. Indicateur de lecture - script direct

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

  • Read renvoie le paramètre normalisé actuel.
var enabled = UO.DropCheckCoord();
UO.Print(Convert.ToString(enabled));

2. Activer la protection de plage - fonction de script

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

  • Les transferts terrestres via MoveItemChecked sont désormais limités à deux cases.
return  RunScenario();
 object? RunScenario()
{
    var enabled = UO.DropCheckCoord(1);
    UO.Print(Convert.ToString(enabled));
    return null;
}

3. Restaurer les paramètres - Classe de script

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

  • La valeur d'origine est enregistrée et restaurée explicitement.
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 old = UO.DropCheckCoord();
        var temporary = UO.DropCheckCoord(0);
        var restored = UO.DropCheckCoord(old);
        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.DropCheckCoord() — UO.DropCheckCoord()

Paramètres: Aucun paramètre.

Résultat: dynamic / Any.

Pendant un appel:

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

case "dropcheckcoord":

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

                    return new InjectionValue(state.DropCheckCoord);

UO.DropCheckCoord(value) — UO.DropCheckCoord(Any)

Paramètres: value (Any)

Résultat: dynamic / Any.

Pendant un appel:

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

case "dropcheckcoord":

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

                    return new InjectionValue(state.DropCheckCoord);

UO.DropDelay

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

Signatures C#

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

Lit ou modifie le délai d'exécution GrabDelay utilisé par les transferts d'éléments.

Paramètres

  • value — Délai facultatif en millisecondes ; les limites du pont à 50..10000.

Valeur de retour

Sans argument int avec le courant GrabDelay. Le formulaire de saisie renvoie null, bien que les métadonnées des deux formulaires contiennent object?.

Comportement

  • SetDropDelay et GetDropDelay utilisent State. GrabDelay. Le paramètre spécifie le délai client des transferts, plutôt que la confirmation de leur achèvement par le serveur.

Scripts C# autonomes

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

Exemple simple

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

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

1. Délai de lecture - script direct

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

  • Read renvoie des millisecondes.
var ms = UO.DropDelay();
UO.Print(Convert.ToString(ms));

2. Définir le délai - Fonction de script

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

  • L'entrée définit 250 ms.
return  RunScenario();
 object? RunScenario()
{
    UO.DropDelay(250);
    return null;
}

3. Bordure inférieure - Classe de script

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

  • Le zéro est limité à 50 ms, après quoi il revient à sa valeur 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 previous = UO.DropDelay();
        UO.DropDelay(0);
        UO.Print(Convert.ToString(UO.DropDelay()));
        UO.DropDelay(previous);
        return null;
    }
}

Implémentation de la commande

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

UO.DropDelay() — UO.DropDelay()

Paramètres: Aucun paramètre.

Résultat: dynamic / Any.

Pendant un appel:

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

case "dropdelay":

                    if (arguments.Length > 0) { bridge.SetDropDelay(Arg(0)); return InjectionValue.Unit; }

                    return new InjectionValue(bridge.GetDropDelay());

UO.DropDelay(value) — UO.DropDelay(Any)

Paramètres: value (Any)

Résultat: dynamic / Any.

Pendant un appel:

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

case "dropdelay":

                    if (arguments.Length > 0) { bridge.SetDropDelay(Arg(0)); return InjectionValue.Unit; }

                    return new InjectionValue(bridge.GetDropDelay());

UO.DropHere

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

Signatures C#

int UO.DropHere(object? @object);

Transfère l'intégralité de l'élément/de la pile spécifié au sol au point actuel du personnage.

Paramètres

  • object — Série d'un élément/caractère spécifique : numéro, chaîne hexadécimale/décimale, self/backpack/lasttarget/lastobject/lastcontainer/lastcorpse/finditem/laststatus ou nom enregistré AddObject. Ce n'est pas type. L'objet doit être chargé ; vérifiez Exists avant d'agir.

Valeur de retour

int 1 — la demande de transfert a été acceptée par le client ; 0 - non terminé. Ce n'est pas serial ou une confirmation 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

  • Un formulaire a été enregistré avec exactement un argument. Pour une partie de la pile, utilisez Drop(item,count) ou MoveItem.
  • X/Y/Z sont extraits du personnage lors de l'appel. Aucun DragItem préalable n'est requis.

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

1. Lancer un objet connu - script direct

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

  • object - serial, remplacer par réel.
  • La pile entière est transférée au personnage.
var ok = UO.DropHere(0x40001234);

2. Utiliser le nom enregistré - Fonction de script

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

  • le butin est spécifié via AddObject.
  • Exists vérifie la disponibilité plutôt que l'autorisation du serveur à migrer.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Exists("loot")))
    {
        var ok = UO.DropHere("loot");
    }

    return null;
}

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

3. Gérer l'échec du client - Classe de script

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

  • ok — int 1/0.
  • Pour confirmer le résultat du serveur, vérifiez séparément la position et le conteneur de l'élément.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var ok = UO.DropHere("loot");
        if (Truth(ok == 0))
        {
            UO.Print("Drop request was not accepted");
        }

        return null;
    }

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

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.DropHere(object) — UO.DropHere(Any)

Paramètres: object (Any)

Résultat: int / Integer.

Pendant un appel:

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

case "drophere":

                    if (arguments.Length > 0)

                        return new InjectionValue(MoveItem(arguments[0], arguments.Length > 1 ? arguments[1] : InjectionValue.Zero, new InjectionValue("ground"), new InjectionValue(GetX()), new InjectionValue(GetY()), new InjectionValue(GetZ())));

                    return InjectionValue.False;

UO.DropItem

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

Signatures C#

dynamic UO.DropItem(object? moveIntoID, object? x, object? y, object? z);

Réinitialise un élément précédemment récupéré avec succès par Drag/DragItem dans le même runtime.

Paramètres

  • moveIntoID — Destination série, backpack ou nom d'ensemble AddObject. Le chiffre 0 signifie terre. Utilisez backpack plutôt que self : cet argument de bas niveau résout self en serial d'un personnage.
  • x — Pour un récipient — placer à l'intérieur de la gump (-1/65535 automatiquement) ; pour la terre - monde X.
  • y — Pour un récipient — placer à l'intérieur de la gump (-1/65535 automatiquement) ; pour la terre - monde Y.
  • z — Réinitialiser la hauteur ; dans le conteneur généralement 0, au sol le point Z réel.

Valeur de retour

int 1 - la réinitialisation a été envoyée et le curseur est marqué Dropped ; 0 - Il n'y a pas eu de DragItem réussi, le curseur a changé/n'est pas accessible ou l'affectation n'est pas valide. Métadonnées object ? la compatibilité ne change pas ce résultat. Ce n'est pas une quantité ou un serial.

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

  • Les quatre arguments sont requis. Cette option ne reprend pas l'élément ; Drop et MoveItem effectuent un report complet serial.
  • On vérifie que c'est bien l'élément mémorisé par ce runtime qui est retenu. Un objet pris par quelqu’un d’autre ou pris à la main ne doit pas tomber accidentellement.
  • Après l'envoi, la mémoire de capture est effacée. Le paramètre GrabDelay ajoute une pause au flux de script. Une panne de serveur est possible après le retour.

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

1. Espace sac à dos automatique - script direct

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

  • MoveIntoID=backpack, X/Y=-1, Z=0.
  • La capture réussie est vérifiée avant la publication.
if (Truth(UO.DragItem("loot", 0)))
{
    var ok = UO.DropItem("backpack", -1, -1, 0);
}

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

2. Espace à l'intérieur du coffre - fonction script

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

  • la poitrine est spécifiée via AddObject. X=60/Y=70 — coordonnées dans son gump.
  • montant=10 fait référence au Drag, DropItem n'a pas son propre montant.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Drag("loot", 10)))
    {
        var ok = UO.DropItem("chest", 60, 70, 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. Placer au sol sous le personnage - classe scénario

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

  • MoveIntoID=0 sélectionne clairement le terrain.
  • X/Y/Z est le point du monde, pas les coordonnées du conteneur.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var x = UO.GetX();
        var y = UO.GetY();
        var z = UO.GetZ();
        if (Truth(UO.DragItem("loot", 0)))
        {
            var ok = UO.DropItem(0, x, y, z);
        }

        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.DropItem(moveIntoID, x, y, z) — UO.DropItem(Any,Any,Any,Any)

Paramètres: moveIntoID (Any), x (Any), y (Any), z (Any)

Résultat: dynamic / Any.

Pendant un appel:

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

case "dropitem": return new InjectionValue(bridge.DropDraggedItem(Arg(0), Arg(1), Arg(2), Arg(3)));

UO.Dye

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

Signatures C#

void UO.Dye(object? dyeObject);
void UO.Dye(object? dyeObject, object? target);

Utilise l'élément de coloration transféré ; le deuxième argument prédéfinit l'objet UO.Wait-target.

Paramètres

  • dyeObject — Numéro de série de l'objet ou nom pris en charge de l'objet self/backpack/lasttarget/saved ; les chaînes numériques et les chaînes 0x sont résolues par l'exécution.
  • target - Objet facultatif/serial prochaine cible. Sans le deuxième argument, aucun nouvel objectif n’est fixé.

Valeur de retour

void - aucune valeur de retour.

Comportement

  • La forme à deux arguments appelle d'abord WaitTargetObject(target), puis UseObject(dyeObject). La forme à un argument utilise uniquement le sujet. Il s'agit d'envoyer des actions ; la couleur, le droit de coloration et le total sont déterminés par le serveur.

Scripts C# autonomes

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

Exemple simple

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

La commande forme une instruction séparée. Le message précédent indique le début de l’appel et ne confirme aucune action du serveur.

UO.Print("Calling UO.Dye");
UO.Dye(UO.LastObject());

1. Utiliser un objet de teinture – Script direct

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

  • Un appel à un argument ne spécifie pas de cible.
var dye = UO.LastObject();
if (Truth(UO.Exists(dye)))
{
    UO.Dye(dye);
}

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

2. Cible sélectionnée de couleur - fonction de script

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

  • Target est placé avant de double-cliquer sur le colorant.
return  RunScenario();
 object? RunScenario()
{
    var dye = UO.LastObject();
    var target = UO.LastTarget();
    if (Truth(UO.Exists(dye)) && Truth(UO.Exists(target)))
    {
        UO.Dye(dye, target);
    }

    return null;
}

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

3. Noms enregistrés - Classe de script

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

  • L'exemple utilise les noms de teinture et de tissu précédemment enregistrés.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        if (Truth(UO.Exists("dye")) && Truth(UO.Exists("cloth")))
        {
            UO.Dye("dye", "cloth");
        }

        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.Dye(dyeObject) — UO.Dye(Any)

Paramètres: dyeObject (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "dye":

                    if (arguments.Length > 1) bridge.WaitTargetObject(Arg(1));

                    bridge.UseObject(Arg(0, bridge.GetLastObject()));

                    break;

UO.Dye(dyeObject, target) — UO.Dye(Any,Any)

Paramètres: dyeObject (Any), target (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "dye":

                    if (arguments.Length > 1) bridge.WaitTargetObject(Arg(1));

                    bridge.UseObject(Arg(0, bridge.GetLastObject()));

                    break;

UO.EasyObject

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

Signatures C#

void UO.EasyObject(object? name);
void UO.EasyObject(object? name, object? @object);

Stocke le nom de l'objet sans requête cible interactive.

Paramètres

  • name — Le nom de l'entrée Objets d'exécution, qui se résout en string.
  • object - Facultatif serial/lien. Sans cela, GetLastObject est préservé.

Valeur de retour

void - aucune valeur de retour.

Comportement

  • State.Objects.Set remplace l'entrée de nom. La forme à un argument utilise le dernier objet utilisé plutôt que LastTarget. La présence d'un objet dans le monde n'est pas vérifiée séparément par cette branche.

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.EasyObject");
UO.EasyObject("last-used");

1. Enregistrer le dernier objet - script direct

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

  • Le nom est donné au LastObject actuel.
UO.EasyObject("last-used");

2. Sauvez-vous - fonction de script

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

  • La forme à deux arguments préserve le serial passé.
return  RunScenario();
 object? RunScenario()
{
    UO.EasyObject("me", UO.Self());
    return null;
}

3. Supprimer une entrée temporaire - Classe de script

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

  • Forget supprime uniquement l'association de nom enregistré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()
    {
        UO.EasyObject("temporary", UO.Self());
        UO.Forget("temporary");
        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.EasyObject(name) — UO.EasyObject(Any)

Paramètres: name (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "easyobject":

                    if (arguments.Length > 1) state.Objects.Set(Text(0), Arg(1));

                    else if (arguments.Length > 0) state.Objects.Set(Text(0), bridge.GetLastObject());

                    break;

UO.EasyObject(name, object) — UO.EasyObject(Any,Any)

Paramètres: name (Any), object (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "easyobject":

                    if (arguments.Length > 1) state.Objects.Set(Text(0), Arg(1));

                    else if (arguments.Length > 0) state.Objects.Set(Text(0), bridge.GetLastObject());

                    break;

UO.EmptyContainer

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

Signatures C#

int UO.EmptyContainer(object? delay);
int UO.EmptyContainer(object? delay, object? source);
int UO.EmptyContainer(object? delay, object? source, object? destination);

Transfère tout le contenu direct d'un coffre, d'un sac ou d'un cadavre vers le conteneur spécifié. Le premier paramètre est toujours le délai en millisecondes. Si aucune source n'est spécifiée, une portée locale apparaît : sélectionnez le conteneur source. La destination par défaut est le sac à dos du personnage actuel.

Paramètres

  • delay — Premier paramètre obligatoire : délai entre les transferts, en millisecondes. Par exemple 350 - 0,35 secondes. Des valeurs entières sont utilisées ; les négatifs sont réduits à 0. GrabDelay n'est pas ajouté séparément à ce délai. La dernière pause est enregistrée afin que la ligne suivante ne dépasse pas la dernière requête.
  • source — Deuxième paramètre facultatif : serial du conteneur source, une chaîne numérique/hexadécimale ou un nom d'objet enregistré. lastobject, lastcontainer, lasttarget, lastcorpse, backpack/my sont pris en charge. Si le paramètre est manquant ou égal à 0, un réticule apparaît. Sélectionnez un objet conteneur ou un cadavre ; Esc annule l'action.
  • destination - Le troisième paramètre facultatif est serial ou le nom enregistré du conteneur de destination. backpack/self/my sélectionnez le sac à dos du personnage. receiving/catchbag sélectionnez le conteneur SetCatchBag installé (ou le sac à dos s'il n'est pas installé). lastcontainer/lastobject/lasttarget/lastcorpse/finditem/laststatus sont valides s'ils se résolvent en un conteneur accessible. Un alias inconnu ou non défini génère une erreur. Si le paramètre n'est pas précisé, le sac à dos est utilisé ; le paramètre du conteneur receiving ne modifie pas ce choix. La destination doit exister et être différente de la source. Ground/0 n'est pas un conteneur de destination valide ici.

Valeur de retour

int : 1 si la source n'était pas vide et qu'une demande de transfert pouvait être envoyée pour chaque élément direct sélectionné ; 0 lorsque la source est vide, la portée annulée, la destination est incorrecte, le délai de téléchargement ou l'échec d'envoi partiel/complet. Ceci est le résultat des demandes des clients et non une garantie de vidage confirmé par le serveur.

Comportement

  • Formes exactes : EmptyContainer(délai), EmptyContainer(délai, source), EmptyContainer(délai, source, destination). Dans le chat en jeu avec le préfixe standard : ,emptycontainer 350 ; du script : UO.EmptyContainer(350).
  • Lors de la visée, la commande attend la sélection, l'annulation ou l'arrêt d'urgence. Le client continue de mettre à jour l'image et le réseau. Esc n'envoie aucun report, n'utilise pas l'ancien objet et renvoie 0. Si un autre viseur remplace cette sélection, l'action est également annulée.
  • Si le contenu n'a pas encore été téléchargé, le client ouvre la source et attend 3000 ms pour que le serveur réponde. Le contenu masqué au client ne peut pas être transféré sans obtenir les données du serveur. Un coffre inaccessible/trop éloigné ou un bannissement de serveur entraînera un échec plutôt que de sélectionner un autre conteneur.
  • Après réception des données, une liste d'éléments directs est créée. Chaque pile est migrée dans son intégralité, avec une demande de capture et de réinitialisation à la fois. Le sac ci-joint est transporté entièrement ; son contenu n'est pas recherché séparément. Les nouveaux éléments ajoutés ultérieurement ne sont pas inclus dans la liste actuelle.
  • Avant chaque demande, il est revérifié que l'article est toujours dans le contenant d'origine. Vous ne pouvez pas imbriquer un conteneur dans lui-même ou dans son propre enfant. Si le curseur est occupé par un autre élément, la commande ne le réinitialise pas en votre nom.
  • Un conteneur de destination manquant n'est pas remplacé par un sac à dos. Un résultat de 1 ne signifie pas que le serveur a accepté toutes les actions : si nécessaire, vérifiez le contenu après la mise à jour du serveur. Un arrêt d'urgence interrompt l'attente ; Les actions déjà envoyées ne sont pas annulées.
  • Un nom stocké inconnu ou un format d'argument invalide provoque une erreur API plutôt qu'un retour 0. Distinguez-le d'un objet manquant serial valide : pour cela, l'opération renvoie 0.

Scripts C# autonomes

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

Exemple simple

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

Le résultat d’un seul appel est affiché dans le journal. Un nombre n’est pas converti en bool ; un tableau est affiché par son nombre d’éléments.

var result = UO.EmptyContainer(350);
UO.Print("EmptyContainer: " + Convert.ToString(result));

1. Sélectionnez un coffre ou un cadavre avec un viseur et transférez-le dans le sac à dos - script direct

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

  • Le seul paramètre delay=350 spécifie l'intervalle 350 ms. la source est manquante, donc le réticule apparaît.
  • la destination manque également : le contenu va dans le sac à dos du personnage. Choisissez le conteneur/cadavre lui-même, pas seulement un élément à l'intérieur.
  • envoyé reçoit 1 ou 0. Le sens de 0 combine annulation, vide et échec ; Voir aussi le magazine pour plus de détails.
UO.Print("Select a chest or corpse");
var sent = UO.EmptyContainer(350);
if (Truth(sent == 0))
{
    UO.Print("Cancelled, empty, unavailable, or a transfer failed");
}

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

2. D'un coffre célèbre à un sac à dos sans lunette - fonction script

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

  • délai=350 ; la source est le vrai serial du coffre, remplacez le ID approximatif par le vôtre. La vue n'apparaît pas.
  • Le troisième paramètre n'est pas spécifié, donc destination=backpack. Tous les types d’articles directs et les piles complètes sont inclus dans le report.
  • Print affiche le résultat de la soumission du client, pas le nombre d'éléments ou la confirmation du serveur.
return  RunScenario();
 object? RunScenario()
{
    var source = "0x40001234";
    var sent = UO.EmptyContainer(350, source);
    UO.Print("Client request result: " + Convert.ToString(sent));
    return null;
}

3. Entre deux conteneurs sélectionnés - classe de script

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

  • AddObject avec un paramètre vous invite à sélectionner un objet et enregistre son nom. Les deux sélections sont effectuées successivement.
  • U EmptyContainer delay=350; source=source_bag; destination=destination_bag. Le troisième paramètre spécifie un sac spécifique au lieu d'un sac à dos.
  • Les noms doivent faire référence à des conteneurs différents. Le AddObject annulé supprime la signification précédente de son nom, de sorte que l'ancien sac n'est pas utilisé accidentellement.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        UO.Print("Select source");
        UO.AddObject("source_bag");
        UO.Print("Select destination");
        UO.AddObject("destination_bag");
        var sent = UO.EmptyContainer(350, "source_bag", "destination_bag");
        UO.Print("Client request result: " + Convert.ToString(sent));
        return null;
    }
}

4. Du dernier conteneur ouvert à un coffre donné - script direct

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

  • delay=500 — intervalle d'une demi-seconde. source=lastcontainer - le dernier conteneur ouvert par le serveur dans ce client.
  • destination - ID explicite de votre poitrine ; remplacer l'exemple. lastcontainer et lastobject ont des significations différentes : le dernier conteneur ouvert et le dernier objet utilisé.
  • Avant de commencer, assurez-vous que la dernière source que vous avez ouverte est celle dont vous avez besoin. Le carry n'ouvre pas ses sacs imbriqués de manière récursive.
var destination = "0x40005678";
UO.EmptyContainer(500, "lastcontainer", destination);

5. Sélectionnez une source à vue, précisez la destination à l'avance - fonction script

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

  • délai=350 ; source=0 appelle spécifiquement la portée, tout en conservant la possibilité de passer un troisième paramètre.
  • destination=storage pointe vers un coffre précédemment enregistré. Une fois que vous avez sélectionné une source, le contenu y est transféré.
  • Esc renvoie sent=0 sans emballage. Si le stockage est inconnu ou n'existe pas, un autre conteneur n'est pas automatiquement sélectionné.
return  RunScenario();
 object? RunScenario()
{
    UO.AddObject("storage", "0x40005678");
    var sent = UO.EmptyContainer(350, 0, "storage");
    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.EmptyContainer(delay) — UO.EmptyContainer(Any)

Paramètres: delay (Any)

Résultat: int / Integer.

Pendant un appel:

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

case "emptycontainer": return ExecuteEmptyContainer(arguments);

UO.EmptyContainer(delay, source) — UO.EmptyContainer(Any,Any)

Paramètres: delay (Any), source (Any)

Résultat: int / Integer.

Pendant un appel:

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

case "emptycontainer": return ExecuteEmptyContainer(arguments);

UO.EmptyContainer(delay, source, destination) — UO.EmptyContainer(Any,Any,Any)

Paramètres: delay (Any), source (Any), destination (Any)

Résultat: int / Integer.

Pendant un appel:

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

case "emptycontainer": return ExecuteEmptyContainer(arguments);

UO.Exists

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

Signatures C#

int UO.Exists(object? id);

Vérifie la présence d'un objet non supprimé dans le monde local du client.

Paramètres

  • id — Obligatoire serial/ID d'un objet spécifique : int, chaîne hexadécimale ou alias self, backpack, lasttarget, lastobject, lastcontainer, laststatus, finditem, lastcorpse ou nom AddObject. Ce n'est pas graphic/type. Le nom non spécifié se résout en 0 ; la commande n'ouvre aucune nouvelle cible.

Valeur de retour

int 1 - serial se résout désormais en élément chargé ou mobile. int 0 - l'objet est inconnu du client, supprimé ou l'alias n'est pas défini. Il ne s'agit pas d'une réponse du serveur sur l'existence d'un objet : un élément en dehors de la zone visible peut exister sur le serveur et donner ici 0.

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

Comportement

  • Le modèle client local est lu ; Il n'y a aucune requête au serveur, pas d'attente ni de déplacement.
  • Le résultat fait référence au moment de la lecture. Après UO.Wait ou une autre action, l'objet et ses drapeaux peuvent changer.

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

1. Vérifiez si le sac à dos est disponible - script direct

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

  • L'argument backpack est un alias serial du sac à dos de votre propre personnage.
  • 1 ne signifie pas que le contenu du sac à dos a déjà été entièrement reçu ou qu'il a été ouvert.
var present = UO.Exists("backpack");
if (Truth(present))
{
    UO.Print("Backpack is loaded");
}
else
{
    UO.Print("Backpack is unavailable");
}

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

2. Revérifiez l'enregistrement serial - fonction de script

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

  • target stocke le serial spécifique. La nouvelle valeur lasttarget ne la remplacera pas.
  • Après la pause 500 ms, l'objet pourrait avoir disparu de la visibilité, le contrôle est donc effectué à nouveau.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var target = UO.GetSerial("lasttarget");
    await Delay(500);
    if (Truth(UO.Exists(target)))
    {
        UO.Print(UO.GetName(target));
    }
    else
    {
        UO.Print("Saved target is no longer loaded");
    }

    return null;
}

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

3. Distinguer le formatage ID de la présence d'objet - classe de script

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

  • GetSerial formate le nombre 1073746484 en 0x40001234 même s'il n'y a pas d'objet.
  • Seule la vérification suivante rapporte la présence de ce serial dans le monde local 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()
    {
        var serial = UO.GetSerial("1073746484");
        UO.Print("Serial: " + serial);
        var present = UO.Exists(serial);
        UO.Print("Present 1/0: " + Convert.ToString(present));
        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.Exists(id) — UO.Exists(Integer)

Paramètres: id (Integer/String)

Résultat: int / Integer.

Pendant un appel:

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

public int Exists(int id) => bridge.Exists(id);

UO.Exists(id) — UO.Exists(String)

Paramètres: id (Integer/String)

Résultat: int / Integer.

Pendant un appel:

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

public int Exists(string id) => Exists(GetObject(id));

UO.Forget

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

Signatures C#

void UO.Forget(object? name);

Sans message, supprime le nom stocké des objets d'exécution.

Paramètres

  • name — Le nom de l'entrée qui se convertit en string.

Valeur de retour

void - aucune valeur de retour.

Comportement

  • La branche appelle state.Objects.Remove. Contrairement à DeleteObject, ce formulaire n'imprime pas de confirmation ni ne signale un nom manquant. L'objet du monde du jeu n'est pas supprimé.

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

1. Supprimer le nom temporaire - script direct

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

  • Seule l'association du nom avec serial est supprimée.
UO.EasyObject("temporary",UO.Self());
UO.Forget("temporary");

2. Nom manquant – Fonction de script

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

  • Un nom manquant est autorisé sans message.
return  RunScenario();
 object? RunScenario()
{
    UO.Forget("missing-example-name");
    return null;
}

3. Nom de la variable - classe de script

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

  • La suppression fait référence à la chaîne de nom exacte.
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 name = "temporary";
        UO.EasyObject(name, UO.Self());
        UO.Forget(name);
        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.Forget(name) — UO.Forget(Any)

Paramètres: name (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "forget": if (arguments.Length > 0) state.Objects.Remove(Text(0)); break;

UO.GetAltName

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

Signatures C#

dynamic UO.GetAltName(object? objID);

Lit le titre du personnage connu du client : par exemple, profession ou signature après le nom.

Paramètres

  • objID — Objet serial/ID requis, pas type et pas cliloc. Accepte int, chaîne décimale/hexadécimale, self, backpack, lasttarget, finditem ou nom AddObject. 0 signifie aucun objet.

Valeur de retour

string — texte du champ Titre pour Mobile. Chaîne vide si le titre est inconnu, si l'objet n'est pas un caractère ou si ID est manquant. Il ne s'agit pas de serial, d'un nom complet ou d'un tableau de propriétés. GetAltName utilise le même champ que GetTitle.

Comportement

  • L'appel lui-même lit les données locales, n'attend pas le serveur et n'envoie pas un seul clic. Pour demander un nom/titre, utilisez ClickOnObject seul ; la réponse arrive de manière asynchrone.
  • Une chaîne vide est également acceptable pour un caractère existant. La vérification Exists répond à une autre question : si l'objet est chargé.
  • Dans cette implémentation, le nom alternatif est mappé au champ Titre du personnage.

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

1. Titre de votre personnage - script direct

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

  • ObjID=self — caractère du client actuel.
  • title contient uniquement le titre ; un champ vide ne signifie pas une erreur de script.
var title = UO.GetAltName("self");
UO.Print(title);

2. Vérifier le caractère sélectionné - fonction de script

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

  • ObjID=id — serial de la dernière cible. GetName et le titre sont lus séparément.
  • La cible de l'élément n'a pas de champ Titre et donnera une chaîne vide.
return  RunScenario();
 object? RunScenario()
{
    var id = UO.GetSerial("lasttarget");
    if (Truth(UO.Exists(id)))
    {
        var title = UO.GetAltName(id);
        if (Truth(title != ""))
        {
            UO.Print(UO.GetName(id) + " " + title);
        }
    }

    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. Demander le nom avant de lire - classe de script

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

  • 350 — exemple de pause en millisecondes après un simple clic ; ce n'est pas un paramètre getter.
  • Le serveur peut répondre plus tard ou ne pas transférer le titre. Préserver la gestion des chaînes vides.
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.GetSerial("lasttarget");
        if (Truth(UO.Exists(id)))
        {
            UO.ClickOnObject(id);
            UO.Wait(350);
            UO.Print(UO.GetAltName(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.GetAltName(objID) — UO.GetAltName(Any)

Paramètres: objID (Any)

Résultat: dynamic / Any.

Pendant un appel:

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

case "getaltname": return new InjectionValue(bridge.GetAltName(Arg(0)));

UO.GetColor

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

Signatures C#

string UO.GetColor();
string UO.GetColor(object? id);

Lit l'objet hue et le formate sous forme de chaîne hexadécimale.

Paramètres

  • id est le Serial/ID de l'objet, pas graphic/type. Numéro, chaîne hexadécimale, nom standard self/backpack/lasttarget/lastobject/lastcontainer/laststatus/finditem/lastcorpse ou nom AddObject. L'alias doit être défini ; l'existence est vérifiée par Exists. Le formulaire enregistré sans arguments utilise self.

Valeur de retour

string de la forme "0x0481" - code hue/couleur, quatre chiffres hexadécimaux après 0x. Pour un objet manquant, "0x0000" est renvoyé ; le même code se produit pour un élément non peint. La couleur n'est pas graphic/type ou unique serial.

Comportement

  • Les dernières données déjà connues du client sont lues ; la demande de mise à jour n'est pas envoyée au serveur.
  • Un objet inconnu et une propriété qui n'a pas encore été récupérée peuvent avoir une valeur nulle/vide. Vérifiez Exists et les conditions d'une action particulière.

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

1. Découvrez la couleur du dernier élément - script direct

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

  • id=lastobject - dernier objet utilisé.
  • Le résultat est déjà une chaîne hexadécimale et ne nécessite pas Int2Hex.
var hue = UO.GetColor("lastobject");
UO.Print(hue);

2. Rechercher un objet de la même couleur - fonction script

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

  • type et hue sont des caractéristiques différentes de l'échantillon ; FindType accepte les deux représentations hexadécimales.
  • match - trouvé serial ou une chaîne vide. La couleur ne remplace pas type.
return  RunScenario();
 object? RunScenario()
{
    var sample = UO.GetSerial("lastobject");
    if (Truth(UO.Exists(sample)))
    {
        var type = UO.GetGraphic(sample);
        var hue = UO.GetColor(sample);
        var match = UO.FindType(type, hue, "backpack");
        UO.Print(match);
    }

    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. Convertir hue en entier pour comparaison – classe de script

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

  • GetColor lit self ; Hex2Int convertit le texte hexadécimal en int.
  • Le nul hue n'indique pas à lui seul si un personnage est présent dans le monde.
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 hue = UO.Hex2Int(UO.GetColor("self"));
        if (Truth(hue == 0))
        {
            UO.Print("Hue is 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;
}

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

Paramètres: Aucun paramètre.

Résultat: string / String.

Pendant un appel:

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

public string GetColor() => GetColor(new InjectionValue(bridge.Self));

UO.GetColor(id) — UO.GetColor(Any)

Paramètres: id (Any)

Résultat: string / String.

Pendant un appel:

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

public string GetColor(InjectionValue id) => NumberConversions.ToHex((short)bridge.GetColor(GetObject(id)));

UO.GetFlags

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

Signatures C#

int UO.GetFlags(object? id);

Lit le masque de bits Entity.Flags à partir d’un objet local connu.

Paramètres

  • id — Numéro de série de l'objet ou nom pris en charge de l'objet self/backpack/lasttarget/saved ; les chaînes numériques et les chaînes 0x sont résolues par l'exécution.

Valeur de retour

int - Entity.Flags d'origine. L'entité inconnue/manquante renvoie 0 ; c'est un masque, pas un résultat logique.

Comportement

  • GetObject résout le lien, puis bridge.World.Get lit Entity.Flags sur le flux du jeu. Une valeur nulle peut signifier un objet sans indicateur ou sans modèle ; Exists sépare ces cas. La commande ne demande pas de mise à jour de statut.

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

1. Marquez-vous - script direct

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

  • Le masque du personnage actuel s'affiche.
var flags = UO.GetFlags("self");
UO.Print(Convert.ToString(flags));

2. Indicateurs cibles connus - Fonctionnalité de script

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

  • Le test Exists distingue le modèle manquant.
return  RunScenario();
 object? RunScenario()
{
    var id = UO.LastTarget();
    if (Truth(UO.Exists(id)))
    {
        var flags = UO.GetFlags(id);
        UO.Print(Convert.ToString(flags));
    }

    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. serial manquant - classe de script

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

  • Un serial nul ne correspond généralement pas à une entité et renvoie 0.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var flags = UO.GetFlags(0);
        UO.Print(Convert.ToString(flags));
        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.GetFlags(id) — UO.GetFlags(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 GetFlags(InjectionValue id) => bridge.GetFlags(GetObject(id));

UO.GetGraphic

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

Signatures C#

string UO.GetGraphic();
string UO.GetGraphic(object? id);

Lit le graphic d'un élément ou le body d'un caractère et le renvoie en texte hexadécimal.

Paramètres

  • id — Série d'un objet spécifique ou d'un alias résoluble, tel que "self", "backpack", "lasttarget" ou le nom stocké par AddObject. Le graphique/type n’est pas transmis ici. La forme sans argument utilise self.

Valeur de retour

string de la forme "0x0EED" - objet graphique type/body. Ce n'est pas un ID/serial unique. Pour un objet inconnu, bridge renvoie graphic 0, qui est formaté comme "0x0000". La commande ne renvoie pas true/false.

Comportement

  • La commande lit les données locales du client. Il n'envoie pas de cible et ne modifie pas l'objet sur le serveur.
  • Le nombre 0 peut être une valeur de données valide. Vérifiez l'absence d'un objet par Exists(serial), et pas seulement par la valeur de sa propriété.

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

1. Vérifiez le type d'élément trouvé - script direct

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

  • FindType reçoit type d'or et renvoie serial.
  • GetGraphic(serial) renvoie le texte "0x0EED" ; les variables item et graphic ont des significations différentes.
var item = UO.FindType(0x0EED, -1, "backpack");
if (Truth(item != ""))
{
    var graphic = UO.GetGraphic(item);
    UO.Print("Graphic: " + graphic);
}

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

2. Lisez le body de votre personnage - fonction de script

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

  • La forme sans argument utilise self.
  • body est le code de l'apparence du personnage, pas son serial.
return  RunScenario();
 object? RunScenario()
{
    var body = UO.GetGraphic();
    UO.Print("Body graphic: " + body);
    return null;
}

3. Passer la lecture graphic à une nouvelle recherche - classe de script

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

  • lastobject—échantillon ; graphic est une chaîne hexadécimale que FindType accepte comme type.
  • -1 autorise n'importe quelle couleur, backpack précise la zone de recherche. sameType est à nouveau serial.
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 graphic = UO.GetGraphic("lastobject");
        var sameType = UO.FindType(graphic, -1, "backpack");
        if (Truth(sameType != ""))
        {
            UO.Print("Matching serial: " + sameType);
        }

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

Paramètres: Aucun paramètre.

Résultat: string / String.

Pendant un appel:

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

public string GetGraphics() => GetGraphics(bridge.Self);

UO.GetGraphic(id) — UO.GetGraphic(Integer)

Paramètres: id (Integer/String)

Résultat: string / String.

Pendant un appel:

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

public string GetGraphics(int id) => $"0x{bridge.GetGraphics(id):X4}";

UO.GetGraphic(id) — UO.GetGraphic(String)

Paramètres: id (Integer/String)

Résultat: string / String.

Pendant un appel:

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

public string GetGraphics(string id) => GetGraphics(GetObject(id));

UO.GetLayer

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

Signatures C#

string UO.GetLayer();
string UO.GetLayer(object? id);

Paramètres

  • id — Série d'un objet spécifique ou d'un alias résoluble, tel que "self", "backpack", "lasttarget" ou le nom stocké par AddObject. Le graphique/type n’est pas transmis ici. La forme sans argument utilise self.

Valeur de retour

string est le nom du calque, tel que "Rhand", "Lhand", "Hat", "Bpack" ou "Mount". Le premier nom canonique du numéro de couche est renvoyé, donc le casque est affiché sous la forme "Hat" et Backpack sous la forme "Bpack". Le calque 0, l'élément inconnu ou self donnent "Invalide". Un nombre inconnu non nul est au format « 0xNN ». Ce n'est pas serial, ni graphic, ni la hauteur Z.

Comportement

  • La commande lit les données locales du client. Il n'envoie pas de cible et ne modifie pas l'objet sur le serveur.
  • Le nombre 0 peut être une valeur de données valide. Vérifiez l'absence d'un objet par Exists(serial), et pas seulement par la valeur de sa propriété.

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

1. Déterminer le calque d'un objet dans la main droite - script direct

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

  • ObjAtLayer("Rhand") sélectionne un élément dans la main droite ; 0 signifie emplacement vide.
  • GetLayer reçoit serial de l'élément trouvé et renvoie la chaîne "Rhand".
object? item = UO.ObjAtLayer("Rhand");
if (item is string serial)
{
    var layer = UO.GetLayer(serial);
    UO.Print(layer);
}

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

2. Vérifier le nom de la couche du sac à dos - Fonction de script

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

  • id="backpack" — serial du sac à dos du personnage actuel.
  • Le nom canonique Bpack est coché, pas l'alias Backpack.
return  RunScenario();
 object? RunScenario()
{
    var layer = UO.GetLayer("backpack");
    if (Truth(layer == "Bpack"))
    {
        UO.Print("Player backpack layer");
    }
    else
    {
        UO.Print("Layer: " + layer);
    }

    return null;
}

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

3. Gérer le manque d'équipement - Classe de script

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

  • lastobject doit être un véritable alias de l'objet.
  • Invalide signifie couche zéro. Cela ne prouve pas en soi que l'article a disparu : l'article dans le sac n'est pas non plus équipé.
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 layer = UO.GetLayer("lastobject");
        if (Truth(layer == "Invalid"))
        {
            UO.Print("No equipment layer");
        }
        else
        {
            UO.Print("Equipment layer: " + layer);
        }

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

Paramètres: Aucun paramètre.

Résultat: string / String.

Pendant un appel:

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

public string GetLayer() => GetLayer(new InjectionValue(bridge.Self));

UO.GetLayer(id) — UO.GetLayer(Any)

Paramètres: id (Any)

Résultat: string / String.

Pendant un appel:

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

public string GetLayer(InjectionValue id) => ConvertLayer(bridge.GetLayer(GetObject(id)));

UO.GetLocked

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

Signatures C#

int UO.GetLocked(object? id);

Vérifie la paralysie mobile.

Paramètres

  • id — Obligatoire serial/ID d'un objet spécifique : int, chaîne hexadécimale ou alias self, backpack, lasttarget, lastobject, lastcontainer, laststatus, finditem, lastcorpse ou nom AddObject. Ce n'est pas graphic/type. Le nom non spécifié se résout en 0 ; la commande n'ouvre aucune nouvelle cible. L'argument est requis; pour vous-même, passez self.

Valeur de retour

int 1 - chargé mobile a l'attribut IsParalyzed. int 0 - l'attribut est manquant, l'objet n'est pas mobile, inconnu ou supprimé. Malgré le nom Locked, il ne s'agit pas d'un verrou de poitrine, d'un objet sécurisé ou d'une raison quelconque pour laquelle il est impossible de bouger. Le même drapeau se lit comme Paralyzed.

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

  • Le modèle client local est lu ; Il n'y a aucune requête au serveur, pas d'attente ni de déplacement.
  • Le résultat fait référence au moment de la lecture. Après UO.Wait ou une autre action, l'objet et ses drapeaux peuvent changer.
  • Malgré le nom Locked, il ne s'agit pas d'un verrou de poitrine, d'un objet sécurisé ou d'une raison quelconque pour laquelle il est impossible de bouger. Le même indicateur que Paralyzed est lu.

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

1. Vérifiez votre propre état - script direct

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

  • L'argument self sélectionne explicitement son caractère. état - 1/0 uniquement.
  • Malgré le nom Locked, il ne s'agit pas d'un verrou de poitrine, d'un objet sécurisé ou d'une raison quelconque pour laquelle il est impossible de bouger. Le même indicateur que Paralyzed est lu.
var state = UO.GetLocked("self");
var paralyzed = UO.Paralyzed();
UO.Print("GetLocked: " + Convert.ToString(state));
UO.Print("Paralyzed: " + Convert.ToString(paralyzed));

2. Vérifier le mobile sélectionné - fonction de script

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

  • IsNpc exclut le sujet et l'objet inconnu. target stocke un seul serial plutôt qu'une référence en direct à un lasttarget changeant.
  • Le résultat fait référence au champ IsParalyzed. Les données ne sont mises à jour qu'une fois que le client a reçu l'état approprié.
return  RunScenario();
 object? RunScenario()
{
    var target = UO.GetSerial("lasttarget");
    if (Truth(UO.IsNPC(target)))
    {
        var state = UO.GetLocked(target);
        UO.Print("Selected mobile state 1/0: " + Convert.ToString(state));
    }
    else
    {
        UO.Print("No loaded mobile selected");
    }

    return null;
}

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

3. Comparez l'état avant et après la pause - classe de script

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

  • UO.Wait(500) — pause en millisecondes. Après cela, il est vérifié séparément que mobile existe toujours.
  • Deux photographies sont comparées. Des modifications intermédiaires peuvent être manquées, et il ne s'agit pas d'un abonnement continu aux événements du serveur.
return await new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenarioAsync();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

    async public Task<object?> RunScenarioAsync()
    {
        var target = UO.GetSerial("lasttarget");
        if (Truth(UO.IsNPC(target)))
        {
            var before = UO.GetLocked(target);
            await Delay(500);
            if (Truth(UO.IsNPC(target)))
            {
                var after = UO.GetLocked(target);
                if (Truth(before != after))
                {
                    UO.Print("Flag changed: " + Convert.ToString(before) + " -> " + Convert.ToString(after));
                }
            }
            else
            {
                UO.Print("Mobile left the local world");
            }
        }

        return null;
    }

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

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.GetLocked(id) — UO.GetLocked(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 GetLocked(InjectionValue id) => bridge.GetLocked(GetObject(id));

UO.GetName

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

Signatures C#

string UO.GetName();
string UO.GetName(object? id);

Lit le nom d'un élément ou d'un personnage connu du client.

Paramètres

  • id est le Serial/ID de l'objet, pas graphic/type. Numéro, chaîne hexadécimale, nom standard self/backpack/lasttarget/lastobject/lastcontainer/laststatus/finditem/lastcorpse ou nom AddObject. L'alias doit être défini ; l'existence est vérifiée par Exists. Le formulaire enregistré sans arguments utilise self.

Valeur de retour

string — nom de l'objet. Un objet inconnu ou un nom qui n'a pas encore été obtenu donne la chaîne vide "". Ce n'est pas serial, ni type, ni la liste complète des propriétés de l'info-bulle.

Comportement

  • Les dernières données déjà connues du client sont lues ; la demande de mise à jour n'est pas envoyée au serveur.
  • Un objet inconnu et une propriété qui n'a pas encore été récupérée peuvent avoir une valeur nulle/vide. Vérifiez Exists et les conditions d'une action particulière.

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

1. Imprimer le nom du personnage - script direct

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

  • Sans argument, self est utilisé.
  • Le résultat est le texte du nom, il peut être affiché directement.
var name = UO.GetName();
UO.Print(name);

2. Processus nom de cible inconnu - fonction de script

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

  • lasttarget — alias de l'objet. GetName n'ouvre pas de nouvelle cible.
  • Un nom vide ne prouve pas l'absence d'un objet : les informations sur serial sans nom auraient pu venir en premier.
return  RunScenario();
 object? RunScenario()
{
    var name = UO.GetName("lasttarget");
    if (Truth(name == ""))
    {
        UO.Print("Name is not available");
    }
    else
    {
        UO.Print("Target: " + name);
    }

    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. Comparer le nom sans tenir compte de la casse - classe de script

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

  • ToLowerInvariant convertit la chaîne en minuscules pour comparaison.
  • Le nom est défini par le serveur et peut être localisé. Pour filtrer par type de graphique, utilisez FindType/GetGraphic.
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 name = UO.GetName("lastobject");
        if (Truth(Convert.ToString(name) == "gold"))
        {
            UO.Print("Known name matches");
        }

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

Paramètres: Aucun paramètre.

Résultat: string / String.

Pendant un appel:

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

public string GetName() => GetName("self");

UO.GetName(id) — UO.GetName(Any)

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

Résultat: string / Any.

Pendant un appel:

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

case "getname":

                case "charname": return new InjectionValue(bridge.GetName(Arg(0, bridge.Self)));

UO.GetName(id) — UO.GetName(Integer)

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

Résultat: string / String.

Pendant un appel:

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

public string GetName(int id) => bridge.GetName(id);

UO.GetName(id) — UO.GetName(String)

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

Résultat: string / String.

Pendant un appel:

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

public string GetName(string id) => GetName(GetObject(id));

UO.GetQuantity

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

Signatures C#

int UO.GetQuantity(object? id);

Lit le nombre d'unités dans une pile d'éléments.

Paramètres

  • id est le Serial/ID de l'objet, pas graphic/type. Numéro, chaîne hexadécimale, nom standard self/backpack/lasttarget/lastobject/lastcontainer/laststatus/finditem/lastcorpse ou nom AddObject. L'alias doit être défini ; l'existence est vérifiée par Exists. Le formulaire enregistré sans arguments utilise self. Pour cette commande, l'identifiant est requis.

Valeur de retour

int — Champ de montant d'un article spécifique. Une pile d'unités 1000 renvoie généralement 1000 ; article unique - 1. Pour l'inconnu serial et pour le personnage, 0 revient. Il ne s'agit pas du nombre d'éléments enfants du coffre ni de la limite d'éléments de la commande MassMove.

Comportement

  • Les dernières données déjà connues du client sont lues ; la demande de mise à jour n'est pas envoyée au serveur.
  • Un objet inconnu et une propriété qui n'a pas encore été récupérée peuvent avoir une valeur nulle/vide. Vérifiez Exists et les conditions d'une action particulière.

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

1. Afficher la taille de la pile trouvée - script direct

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

  • FindType recherche un type d'or de n'importe quelle couleur dans un sac à dos.
  • l'or contient un serial, donc le montant ne s'applique qu'à une pile trouvée.
var gold = UO.FindType(0x0EED, -1, "backpack");
if (Truth(gold != ""))
{
    var amount = UO.GetQuantity(gold);
    UO.Print("Units in this stack: " + Convert.ToString(amount));
}

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

2. Vérifier la quantité minimale - fonction script

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

  • id=sample - dernier élément utilisé.
  • 50 signifie ceux de la pile donnée. Les éléments individuels 50 ne sont pas comptés ici.
return  RunScenario();
 object? RunScenario()
{
    var sample = UO.GetSerial("lastobject");
    if (Truth(UO.Exists(sample)))
    {
        if (Truth(UO.GetQuantity(sample) >= 50))
        {
            UO.Print("At least 50 units in this item");
        }
    }

    return null;
}

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

3. Distinguer le nombre de piles de celles-ci - classe de scénario

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

  • FindCount fait référence aux résultats de la dernière recherche ; GetQuantity - à un serial.
  • Les chiffres peuvent varier considérablement. La quantité MassMove limite les articles entiers, y compris les piles.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var item = UO.FindType(0x0EED, -1, "backpack");
        var stacks = UO.FindCount();
        if (Truth(item != ""))
        {
            var units = UO.GetQuantity(item);
            UO.Print("Matching items: " + Convert.ToString(stacks));
            UO.Print("Units in selected item: " + Convert.ToString(units));
        }

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

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

Résultat: int / Any.

Pendant un appel:

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

case "getquantity": return new InjectionValue(bridge.GetQuantity(Arg(0)));

UO.GetQuantity(id) — UO.GetQuantity(Integer)

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

Résultat: int / Integer.

Pendant un appel:

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

public int GetQuantity(int id) => bridge.GetQuantity(id);

UO.GetQuantity(id) — UO.GetQuantity(String)

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

Résultat: int / Integer.

Pendant un appel:

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

public int GetQuantity(string id) => GetQuantity(GetObject(id));

UO.GetSerial

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

Signatures C#

string UO.GetSerial();
string UO.GetSerial(object? id);

Résout le nom de l'objet en son serial et formate serial sous forme de chaîne hexadécimale.

Paramètres

  • id - Chaîne facultative : alias standard, nom AddObject ou texte numérique (décimal/hex). Sans argument, le serial du caractère actuel est utilisé.

Valeur de retour

string de la forme "0x40001234" est un objet serial/ID unique, huit chiffres hexadécimaux après 0x. Le nom non résolu donne "0x00000000". Ce n'est pas type. Le texte numérique est formaté même si aucun objet de ce type n'est chargé ; GetSerial ne vérifie pas lui-même Exists.

Comportement

  • Les noms d'alias sont lus à partir de l'état actuel du script/client. La chaîne enregistrée serial ne change pas automatiquement si l'alias pointe ensuite vers un objet différent.

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

1. Obtenez ID de votre personnage - script direct

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

  • Il n'y a aucun paramètre, self est sélectionné.
  • serial — chaîne hexadécimale. La valeur 0x00000000 signifie aucun caractère serial.
var serial = UO.GetSerial();
UO.Print(serial);

2. Utiliser en toute sécurité le nom de famille sélectionné - Fonction de script

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

  • id="lasttarget" se résout en serial dernière cible.
  • Exists vérifie l'existence d'un objet, GetName lit son nom connu du client.
return  RunScenario();
 object? RunScenario()
{
    var serial = UO.GetSerial("lasttarget");
    if (Truth(UO.Exists(serial)))
    {
        UO.Print(UO.GetName(serial));
    }
    else
    {
        UO.Print("Target is not loaded");
    }

    return null;
}

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

3. Comparer les représentations numériques - Classe de script

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

  • id est une chaîne avec le nombre décimal serial 1073746484.
  • Le résultat 0x40001234 montre le formatage. Ceci est un exemple de nombre, il ne crée pas d'objet et ne garantit pas son existence.
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 serial = UO.GetSerial("1073746484");
        UO.Print(serial);
        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.GetSerial() — UO.GetSerial()

Paramètres: Aucun paramètre.

Résultat: string / String.

Pendant un appel:

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

public string GetSerial() => NumberConversions.ToHex(bridge.Self);

UO.GetSerial(id) — UO.GetSerial(String)

Paramètres: id (String)

Résultat: string / String.

Pendant un appel:

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

public string GetSerial(string id) => NumberConversions.ToHex(GetObject(id));

UO.GetTooltip

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

Signatures C#

dynamic UO.GetTooltip(object? objID);

Lit le texte des propriétés de l'objet fini à partir de OPL. GetTooltip et GetCliloc sont des synonymes.

Paramètres

  • objID — Objet serial/ID requis, pas type et pas cliloc. Accepte int, chaîne décimale/hexadécimale, self, backpack, lasttarget, finditem ou nom AddObject. 0 signifie aucun objet.

Valeur de retour

string — le nom et le texte des propriétés, séparés par une nouvelle ligne, ou uniquement la partie non vide. Chaîne vide si ObjID=0 ou si les propriétés ne sont pas reçues. C'est un texte tout fait ; le cliloc numérique ID et les paramètres sont renvoyés par GetTooltipRec.

Comportement

  • Si l'entrée existe déjà dans OPL, son texte est renvoyé immédiatement. S'il n'y a pas d'entrée, une demande de propriété est envoyée et une réponse est attendue jusqu'à 200 ms avec une vérification toutes les 10 ms. Une pause ne garantit pas une réponse.
  • Nous avons besoin d'un objet accessible et d'une prise en charge des propriétés par le serveur. Un résultat vide n'est pas une preuve de l'absence de l'objet : utilisez Exists seul.
  • Le texte peut contenir du balisage du serveur. N'analysez pas les propriétés numériques par position de ligne ; utilisez GetTooltipRec pour cela.

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

1. Propriétés d'un objet dans un sac à dos - script direct

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

  • FindType : or 0x0EED, n'importe quel hue=-1, contenu direct backpack. ObjID=élément - trouvé serial.
  • Le résultat du getter est le texte, pas la quantité d'or. Pour la quantité, utilisez FindCount(article).
var item = UO.FindType(0x0EED, -1, "backpack");
if (Truth(item != ""))
{
    UO.Print(UO.GetTooltip(item));
}

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

2. Gérer aucune réponse - Fonction de script

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

  • ObjID=lasttarget doit pointer vers l'objet souhaité.
  • Une chaîne vide est traitée séparément ; Il n’est pas nécessaire de répéter automatiquement la demande dans une boucle sans fin.
return  RunScenario();
 object? RunScenario()
{
    var text = UO.GetTooltip("lasttarget");
    if (Truth(text == ""))
    {
        UO.Print("No properties received");
    }
    else
    {
        UO.Print(text);
    }

    return null;
}

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

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

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

  • id et save sont des variables distinctes : le ID unique de l'objet et un instantané de son texte.
  • enregistré ne changera pas automatiquement si les propriétés sur le serveur changent ultérieurement.
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.GetSerial("lasttarget");
        var saved = UO.GetTooltip(id);
        UO.Print("Object: 0x" + Hex(id));
        UO.Print(saved);
        return null;
    }

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

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

Paramètres: objID (Any)

Résultat: dynamic / Any.

Pendant un appel:

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

case "getcliloc":

                case "gettooltip":

                    return new InjectionValue(bridge.GetTooltip(Arg(0)));

UO.GetTooltipRec

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

Signatures C#

dynamic UO.GetTooltipRec(object? objID);

Lit les propriétés structurées : cliloc ID et les paramètres de chaque entrée OPL.

Paramètres

  • objID — Objet serial/ID requis, pas type et pas cliloc. Accepte int, chaîne décimale/hexadécimale, self, backpack, lasttarget, finditem ou nom AddObject. 0 signifie aucun objet.

Valeur de retour

Array est un instantané unique de lignes de propriétés. Chaque ligne est égale à [clilocID:int, settings:Array]. rows[i][0] est le numéro du message localisé, rows[i][1] est un tableau de paramètres. ArrayLength(lignes) — nombre de propriétés ; ArrayLength(paramètres) — le nombre de paramètres pour une propriété. Un tableau vide si ObjID=0 ou aucun enregistrement reçu. Ceci n'est pas une liste d'éléments ID ou un texte terminé.

Comportement

  • L'entrée du cache est renvoyée immédiatement. Si OPL est manquant, les propriétés sont interrogées avec une attente pouvant aller jusqu'à 120 ms ; l'annulation de la procédure interrompt l'attente. Le OPL vide connu ne provoque pas d'anticipation.
  • Les onglets de service initiaux sont ignorés comme dans ClilocLoader. Les paramètres internes vides enregistrent les positions ; #Le numéro est enregistré sous forme de chaîne pour une localisation ultérieure. Les paramètres inconnus produisent un tableau vide.
  • La modification du tableau renvoyé ne modifie pas le cache du client. Pour le texte, utilisez GetTooltip/GetCliloc ; pour traduire une ligne - GetClilocByID(clilocID, paramètres).

Scripts C# autonomes

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

Exemple simple

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

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

1. Afficher tous les numéros de propriété - script direct

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

  • ObjID=lasttarget — objet. les lignes contiennent des propriétés, i est l'index de 0. row[0] est cliloc, pas serial.
  • La boucle échoue sur un tableau vide. Chaque enregistrement est traité une fois.
var rows = UO.GetTooltipRec("lasttarget");
var i = 0;
while (Truth(i < ArrayLength(rows)))
{
    var row = rows[i];
    UO.Print("Cliloc: " + Convert.ToString(row[0]));
    i = i + 1;
}

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

2. Traduire chaque enregistrement avec ses paramètres - fonction script

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

  • GetClilocByID reçoit clilocID=row[0] et un tableau de substitution=row[1].
  • Les paramètres sont conservés dans l'ordre. Ne transmettez pas la ligne entière au lieu d’un tableau de paramètres.
return  RunScenario();
 object? RunScenario()
{
    var rows = UO.GetTooltipRec("lasttarget");
    var i = 0;
    while (Truth(i < ArrayLength(rows)))
    {
        var row = rows[i];
        var text = UO.GetClilocByID(row[0], row[1]);
        UO.Print(text);
        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. Récupère le paramètre numérique d'une propriété connue - classe de script

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

  • recherché - exemple de propriété ID ; remplacez-le par le cliloc souhaité. args[0] est le premier paramètre, initialement string.
  • Le nombre de paramètres et le format des nombres sont vérifiés avant Val. Le paramètre peut être du texte ou un lien #cliloc.
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 rows = UO.GetTooltipRec("lasttarget");
        var wanted = 1060401;
        var i = 0;
        while (Truth(i < ArrayLength(rows)))
        {
            var row = rows[i];
            var args = row[1];
            if (Truth(row[0] == wanted) && Truth(ArrayLength(args) > 0))
            {
                if (Truth(IsNumeric(args[0])))
                {
                    UO.Print("Value: " + Convert.ToString(Val(args[0])));
                }
            }

            i = i + 1;
        }

        return null;
    }

    int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
    bool IsNumeric(object? value) => double.TryParse(Convert.ToString(value), System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out _);
    bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
    double Val(object? value) => double.TryParse(Convert.ToString(value), System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out var number) ? number : 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.GetTooltipRec(objID) — UO.GetTooltipRec(Any)

Paramètres: objID (Any)

Résultat: dynamic / Array.

Pendant un appel:

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

case "gettooltiprec":

                    return new InjectionValue(bridge.GetTooltipRecords(Arg(0)).Select(entry =>

                        new InjectionValue(new[]

                        {

                            new InjectionValue(entry.ClilocID),

                            new InjectionValue(entry.Parameters.Select(value => new InjectionValue(value)).ToArray())

                        })).ToArray());

UO.GetType

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

Signatures C#

dynamic UO.GetType(object? objID);

Lit le numérique graphic d'un élément ou body d'un caractère.

Paramètres

Valeur de retour

int - graphic/type d'un objet ou body d'un personnage, par exemple 0x0EED (3821) pour l'or. La valeur 0 est renvoyée si l'objet n'est pas trouvé. GetType ne renvoie pas serial ni le texte "0x..." ; la forme de chaîne est donnée par GetGraphic.

Comportement

  • La commande lit les données locales du client. Il n'envoie pas de cible et ne modifie pas l'objet sur le serveur.
  • Le nombre 0 peut être une valeur de données valide. Vérifiez l'absence d'un objet par Exists(serial), et pas seulement par la valeur de sa propriété.

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

1. Comparez le type numérique avec une constante - script direct

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

  • ObjID="lastobject" - alias d'un objet spécifique.
  • 0x0EED est le nombre de graphic ; La comparaison ne recherche pas d'objet avec un tel serial.
var graphic = UO.GetType("lastobject");
if (Truth(graphic == 0x0EED))
{
    UO.Print("Gold graphic");
}

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

2. Obtenez le type de votre propre sac à dos - fonction de script

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

  • ObjID="backpack" - sac à dos actuel.
  • Convert.ToString formate le nombre renvoyé pour la sortie.
return  RunScenario();
 object? RunScenario()
{
    var graphic = UO.GetType("backpack");
    UO.Print("Backpack type: " + Convert.ToString(graphic));
    return null;
}

3. Vérifier l'existence d'un objet avant de lire le type - classe de script

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

  • La chaîne vide FindType est vérifiée avant Exists.
  • Exists renvoie le booléen 1/0 ; GetType renvoie le nombre graphic.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var item = UO.FindType(0x0EED, -1, "backpack");
        if (Truth(item != ""))
        {
            if (Truth(UO.Exists(item)))
            {
                UO.Print("Type: " + Convert.ToString(UO.GetType(item)));
            }
        }

        return null;
    }

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

Implémentation de la commande

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

UO.GetType(objID) — UO.GetType(Any)

Paramètres: objID (Any)

Résultat: dynamic / Any.

Pendant un appel:

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

case "gettype": return new InjectionValue(bridge.GetGraphics(Arg(0)));

UO.Grab

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

Signatures C#

int UO.Grab();
int UO.Grab(object? id);
int UO.Grab(object? amount, object? id);
int UO.Grab(object? amount, object? item, object? container);
int UO.Grab(object? amount, object? item, object? container, object? timeout);

Transfère un élément vers le conteneur spécifié/récepteur ou ouvre la sélection d'éléments.

Paramètres

  • id — Numéro de série/alias de l'article. Sans arguments, la sélection interactive commence ; avec un argument exactement 1 l'unité de cet élément est prise.
  • item — Numéro de série/alias de l'article. Sans arguments, la sélection interactive commence ; avec un argument exactement 1 l'unité de cet élément est prise.
  • id / item — Numéro de série/alias de l'article. Sans arguments, la sélection interactive commence ; avec un argument exactement 1 l'unité de cet élément est prise.
  • amount - Dans les formulaires 2..4 - quantité comme premier argument, puis article. 0 désigne la pile entière selon les règles MoveItem ; ne modifiez pas l'ordre avec le formulaire Grab(item).
  • container - Formulaires 3/4 uniquement : Affectation explicite. Sans cela - état.ReceivingContainer, si >0, sinon backpack. Les lignes self/my/backpack dans la destination signifient sac à dos ; ground - masse.
  • timeout - 4 formulaire uniquement, millisecondes. Envoyé à CompactMoveItem en attente de confirmation ; les coordonnées ground sont tirées de self, conteneur - 0xFFFF/0xFFFF/0.

Valeur de retour

Indicateur numérique int : 1 — sélection interactive acceptée, ou transfert accepté/confirmé selon la forme sélectionnée ; 0 - échec/aucun élément approprié. Un résultat sans argument ne signifie pas que l'élément a déjà été transféré.

Comportement

  • CompactGrab conserve la forme historique Grab(item)=1 unité. Les formulaires sans délai d'attente utilisent CompactMoveItem sans forcer une attente de confirmation ; le formulaire avec timeout précise UO.Wait=true.
  • La série 0 donne immédiatement 0. Les objets non résolus/inappropriés sont vérifiés davantage par MoveItem. Les règles du serveur, la quantité de pile et le conteneur actuel affectent le résultat. Trois/quatre arguments ne sont pas des coordonnées de dépôt.
  • montant<=0 demande la pile entière. Dans un formulaire avec timeout, une pause négative devient 0, mais au moins une vérification locale est effectuée ; entre les chèques UO.Wait(10). Le transfert partiel est confirmé par une diminution de la quantité initiale, le transfert complet est confirmé par l'affectation et pour ground X/Y/Z. Il s'agit d'une observation de l'état du monde, pas d'une nouvelle réponse protocolaire à la demande ID ; un état déjà adapté peut donner 1 immédiatement. Le délai d'attente donne 0 même si la demande a déjà été 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.

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

1. Appel direct - script direct

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

  • Transfère un élément vers le conteneur spécifié/récepteur ou ouvre la sélection d'éléments.
var accepted = UO.Grab();
UO.Print(accepted);

2. Option explicite - fonction de script

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

  • CompactGrab conserve la forme historique Grab(item)=1 unité. Les formulaires sans délai d'attente utilisent CompactMoveItem sans forcer une attente de confirmation ; le formulaire avec timeout précise UO.Wait=true.
return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.Exists("lastobject")))
    {
        UO.Print(UO.Grab("lastobject"));
    }

    return null;
}

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

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

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

  • La série 0 donne immédiatement 0. Les objets non résolus/inappropriés sont vérifiés davantage par MoveItem. Les règles du serveur, la quantité de pile et le conteneur actuel affectent le résultat. Trois/quatre arguments ne sont pas des coordonnées de dépôt.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        if (Truth(UO.Exists("lastobject")))
        {
            UO.Print(UO.Grab(0, "lastobject", "backpack", 2000));
        }

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

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 Grab() => bridge.RequestInteractiveGrabTarget();

UO.Grab(id) — UO.Grab(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 Grab(InjectionValue id) => CompactGrab(new[] { id });

UO.Grab(amount, id) — UO.Grab(Any,Any)

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

Résultat: int / Any.

Pendant un appel:

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

case "grab": return new InjectionValue(CompactGrab(arguments));

UO.Grab(amount, id) — UO.Grab(Integer,Integer)

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

Résultat: int / Integer.

Pendant un appel:

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

public int Grab(int amount, int id) => CompactGrab(new[] { new InjectionValue(amount), new InjectionValue(id) });

UO.Grab(amount, id) — UO.Grab(Integer,String)

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

Résultat: int / Integer.

Pendant un appel:

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

public int Grab(int amount, string id) => CompactGrab(new[] { new InjectionValue(amount), new InjectionValue(id) });

UO.Grab(amount, id) — UO.Grab(String,String)

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

Résultat: int / Integer.

Pendant un appel:

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

public int Grab(string amount, string id) => CompactGrab(new[] { new InjectionValue(amount), new InjectionValue(id) });

UO.Grab(amount, item, container) — UO.Grab(Any,Any,Any)

Paramètres: amount (Any), item (Any), container (Any)

Résultat: int / Integer.

Pendant un appel:

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

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

values => new InjectionValue(CompactGrab(values))

UO.Grab(amount, item, container, timeout) — UO.Grab(Any,Any,Any,Any)

Paramètres: amount (Any), item (Any), container (Any), timeout (Any)

Résultat: int / Integer.

Pendant un appel:

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

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

values => new InjectionValue(CompactGrab(values))

UO.IsMovable

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

Signatures C#

int UO.IsMovable(object? objID);

Vérifie les signes locaux de portabilité d'un élément connu à l'aide des règles de sélection Classic UO.

Paramètres

  • objID — Obligatoire serial/ID d'un objet spécifique : int, chaîne hexadécimale ou alias self, backpack, lasttarget, lastobject, lastcontainer, laststatus, finditem, lastcorpse ou nom AddObject. Ce n'est pas graphic/type. Le nom non spécifié se résout en 0 ; la commande n'ouvre aucune nouvelle cible.

Valeur de retour

int 1 - l'article n'est pas retiré, ni multi, et n'est pas bloqué par la règle locale de poids/mobile pour les objets au sol. int 0 - mobile, multi, objet inconnu/supprimé ou objet bloqué au sol. 1 ne garantit pas un Drag/MoveItem réussi : la plage, l'accès, l'état du curseur et la décision finale du serveur sont vérifiés séparément.

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

  • Le modèle client local est lu ; Il n'y a aucune requête au serveur, pas d'attente ni de déplacement.
  • Le résultat fait référence au moment de la lecture. Après UO.Wait ou une autre action, l'objet et ses drapeaux peuvent changer.
  • Au sol, un élément est considéré comme verrouillé lorsque le poids de sa saisie de données de tuile est supérieur à 90 et que le drapeau du serveur mobile est manquant. Les poids 90 et inférieurs ne nécessitent pas ce drapeau.
  • A l’intérieur d’un conteneur, la règle du blocage d’un objet au sol ne s’applique pas. Le poids des données de tuile ici est un attribut de service, pas GetQuantity ni le poids actuel du caractère.
  • D'autres documents client peuvent avoir des descriptions de poids différentes. Ceci décrit la règle réelle GameActions.PickUp de ce client.

Scripts C# autonomes

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

Exemple simple

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

Le résultat d’un seul appel est affiché dans le journal. Un nombre n’est pas converti en bool ; un tableau est affiché par son nombre d’éléments.

var result = UO.IsMovable(UO.GetSerial("lastobject"));
UO.Print("IsMovable: " + Convert.ToString(result));

1. Vérifiez le dernier élément sans bouger - script direct

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

  • item — serial du dernier élément utilisé. Le nombre de biens meubles n'est pas leur quantité.
  • L'exemple ne récupère rien et n'envoie rien au serveur.
var item = UO.GetSerial("lastobject");
var movable = UO.IsMovable(item);
UO.Print("Locally movable 1/0: " + Convert.ToString(movable));

2. Estimez séparément le signe et la distance - fonction de script

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

  • Pour un objet au sol, GetDistance indique la portée connue du client.
  • Même avec moving=1, l'élément peut être trop éloigné. Un résultat positif n'indique pas l'autorisation du serveur de transférer.
return  RunScenario();
 object? RunScenario()
{
    var item = UO.GetSerial("lasttarget");
    if (Truth(UO.Exists(item)))
    {
        var movable = UO.IsMovable(item);
        var distance = UO.GetDistance(item);
        UO.Print("Movable: " + Convert.ToString(movable));
        UO.Print("Distance: " + Convert.ToString(distance));
    }

    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érifiez toute la pile trouvée - classe de script

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

  • FindType sélectionne un or serial de n'importe quelle couleur dans le sac à dos.
  • IsMovable vérifie l'intégralité de l'élément. GetQuantity lit le nombre d'unités séparément ; le résultat IsMovable ne remplace pas ce compteur.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        var item = UO.FindType(0x0EED, -1, "backpack");
        if (Truth(item != ""))
        {
            if (Truth(UO.IsMovable(item)))
            {
                var units = UO.GetQuantity(item);
                UO.Print("Selected stack units: " + Convert.ToString(units));
            }
        }

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

Paramètres: objID (Any)

Résultat: int / Integer.

Pendant un appel:

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

case "ismovable": return new InjectionValue(bridge.IsMovable(Arg(0)));

UO.IsObjectExists

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

Signatures C#

int UO.IsObjectExists(object? objID);

Vérifie la présence d'un objet non supprimé dans le monde local du client.

Paramètres

  • objID — Obligatoire serial/ID d'un objet spécifique : int, chaîne hexadécimale ou alias self, backpack, lasttarget, lastobject, lastcontainer, laststatus, finditem, lastcorpse ou nom AddObject. Ce n'est pas graphic/type. Le nom non spécifié se résout en 0 ; la commande n'ouvre aucune nouvelle cible.

Valeur de retour

int 1 - serial se résout désormais en élément chargé ou mobile. int 0 - l'objet est inconnu du client, supprimé ou l'alias n'est pas défini. Il ne s'agit pas d'une réponse du serveur sur l'existence d'un objet : un élément en dehors de la zone visible peut exister sur le serveur et donner ici 0.

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

Comportement

  • Le modèle client local est lu ; Il n'y a aucune requête au serveur, pas d'attente ni de déplacement.
  • Le résultat fait référence au moment de la lecture. Après UO.Wait ou une autre action, l'objet et ses drapeaux peuvent changer.

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

1. Vérifiez si le sac à dos est disponible - script direct

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

  • L'argument backpack est un alias serial du sac à dos de votre propre personnage.
  • 1 ne signifie pas que le contenu du sac à dos a déjà été entièrement reçu ou qu'il a été ouvert.
var present = UO.IsObjectExists("backpack");
if (Truth(present))
{
    UO.Print("Backpack is loaded");
}
else
{
    UO.Print("Backpack is unavailable");
}

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

2. Revérifiez l'enregistrement serial - fonction de script

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

  • target stocke le serial spécifique. La nouvelle valeur lasttarget ne la remplacera pas.
  • Après la pause 500 ms, l'objet pourrait avoir disparu de la visibilité, le contrôle est donc effectué à nouveau.
return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var target = UO.GetSerial("lasttarget");
    await Delay(500);
    if (Truth(UO.IsObjectExists(target)))
    {
        UO.Print(UO.GetName(target));
    }
    else
    {
        UO.Print("Saved target is no longer loaded");
    }

    return null;
}

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

3. Distinguer le formatage ID de la présence d'objet - classe de script

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

  • GetSerial formate le nombre 1073746484 en 0x40001234 même s'il n'y a pas d'objet.
  • Seule la vérification suivante rapporte la présence de ce serial dans le monde local 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()
    {
        var serial = UO.GetSerial("1073746484");
        UO.Print("Serial: " + serial);
        var present = UO.IsObjectExists(serial);
        UO.Print("Present 1/0: " + Convert.ToString(present));
        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.IsObjectExists(objID) — UO.IsObjectExists(Any)

Paramètres: objID (Any)

Résultat: int / Integer.

Pendant un appel:

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

case "isobjectexists": return new InjectionValue(bridge.Exists(Arg(0)));

UO.LastObject

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

Signatures C#

dynamic UO.LastObject();

Lit serial du dernier objet utilisé.

Paramètres

Il n'y a pas de paramètres.

Valeur de retour

int — enregistré serial ; 0 signifie que serial n'est pas installé. Ce n'est pas bool ni graphic/type ; un ID différent de zéro peut ne plus exister dans le monde.

Comportement

  • Source du champ : _world.LastObject. La commande ne sélectionne, n’utilise ou n’attaque pas l’objet.
  • Lit l'état local actuel. Il n’y a pas de package, de cible ou de mise à jour automatique ; les lectures individuelles peuvent voir différents états.

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

1. Appel direct - script direct

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

  • Lit serial du dernier objet utilisé.
var id = UO.LastObject();
UO.Print(Hex(id));

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

2. Option explicite - fonction de script

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

  • Source du champ : _world.LastObject. La commande ne sélectionne, n’utilise ou n’attaque pas l’objet.
return  RunScenario();
 object? RunScenario()
{
    var id = UO.LastObject();
    if (Truth(id != 0) && Truth(UO.Exists(id)))
    {
        UO.Print(UO.GetName(id));
    }

    return null;
}

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

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

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

  • Lit l'état local actuel. Il n’y a pas de package, de cible ou de mise à jour automatique ; les lectures individuelles peuvent voir différents états.
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 before = UO.LastObject();
        UO.Wait(500);
        var after = UO.LastObject();
        UO.Print(before = after);
        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.LastObject() — UO.LastObject()

Paramètres: Aucun paramètre.

Résultat: dynamic / Any.

Pendant un appel:

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

case "lastobject": return new InjectionValue(bridge.GetLastObject());

UO.MakeFakeItem

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

Signatures C#

void UO.MakeFakeItem(object? @type);
void UO.MakeFakeItem(object? @type, object? serial);
void UO.MakeFakeItem(object? @type, object? serial, object? count);
void UO.MakeFakeItem(object? @type, object? serial, object? count, object? color);
void UO.MakeFakeItem(object? @type, object? serial, object? count, object? color, object? x);
void UO.MakeFakeItem(object? @type, object? serial, object? count, object? color, object? x, object? y);

Crée ou modifie uniquement un élément client local.

Paramètres

  • type - Obligatoire graphic 1..65535 ; sans nom type à ResolveType : cette branche héritée utilise Arg/int.
  • serial - Élément serial facultatif. 0 (par défaut) alloue un ID libre à partir de la plage locale autour de 0x7FFEFFFF ; un élément explicite serial peut correspondre à un élément déjà chargé et changer son modèle local.
  • count - Quantité facultative, par défaut 1. Le non positif devient 1 ; maximum 65535.
  • color - Facultatif hue, par défaut 0 ; limité à 0..65535.
  • x — Coordonnées mondiales facultatives, par défaut self ; les négatifs utilisent self, puis se limitent à 0..65535. Z est toujours le joueur actuel.Z.
  • y — Coordonnées mondiales facultatives, par défaut self ; les négatifs utilisent self, puis se limitent à 0..65535. Z est toujours le joueur actuel.Z.

Valeur de retour

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

Comportement

  • CreateFakeItem nécessite un joueur et un graphic/élément serial valide. GetOrCreateItem renvoie le modèle local ; s'il se trouve dans un conteneur, supprime la connexion. Attribue ground conteneur 0xFFFFFFFF, graphic/amount/hue/X/Y/Z, Layer.Invalid, AllowedToDraw=true, IsDamageable=false et IsMulti=false.
  • La commande Legacy ignore le serial renvoyé. Lorsque 0 affiche un message d'erreur. Le serveur ne crée pas l'objet : l'action ne fournit pas d'objet réel, de butin ou de droits de transfert. Par exemple, laissez serial=0.

Scripts C# autonomes

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

Exemple simple

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

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

1. Appel direct - script direct

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

  • Crée ou modifie uniquement un élément client local.
UO.MakeFakeItem(0x0E21);

2. Option explicite - fonction de script

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

  • CreateFakeItem nécessite un joueur et un graphic/élément serial valide. GetOrCreateItem renvoie le modèle local ; s'il se trouve dans un conteneur, supprime la connexion. Attribue ground conteneur 0xFFFFFFFF, graphic/amount/hue/X/Y/Z, Layer.Invalid, AllowedToDraw=true, IsDamageable=false et IsMulti=false.
return  RunScenario();
 object? RunScenario()
{
    UO.MakeFakeItem(0x0E21, 0, 5, 0);
    return null;
}

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

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

  • La commande Legacy ignore le serial renvoyé. Lorsque 0 affiche un message d'erreur. Le serveur ne crée pas l'objet : l'action ne fournit pas d'objet réel, de butin ou de droits de transfert. Par exemple, laissez serial=0.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        UO.MakeFakeItem(0x0E21, 0, 1, 0, UO.GetX(), UO.GetY());
        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.MakeFakeItem(type) — UO.MakeFakeItem(Any)

Paramètres: type (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "makefakeitem":

                {

                    int graphic = Arg(0);

                    int serial = Arg(1, 0);

                    int amount = Arg(2, 1);

                    int hue = Arg(3, 0);

                    int x = Arg(4, bridge.GetX(bridge.Self));

                    int y = Arg(5, bridge.GetY(bridge.Self));

                    int createdSerial = bridge.CreateFakeItem(graphic, serial, amount, hue, x, y);

                    if (createdSerial == 0)

                        SystemMessage("MakeFakeItem: invalid graphic/serial or no active player.");

                    break;

                }

UO.MakeFakeItem(type, serial) — UO.MakeFakeItem(Any,Any)

Paramètres: type (Any), serial (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "makefakeitem":

                {

                    int graphic = Arg(0);

                    int serial = Arg(1, 0);

                    int amount = Arg(2, 1);

                    int hue = Arg(3, 0);

                    int x = Arg(4, bridge.GetX(bridge.Self));

                    int y = Arg(5, bridge.GetY(bridge.Self));

                    int createdSerial = bridge.CreateFakeItem(graphic, serial, amount, hue, x, y);

                    if (createdSerial == 0)

                        SystemMessage("MakeFakeItem: invalid graphic/serial or no active player.");

                    break;

                }

UO.MakeFakeItem(type, serial, count) — UO.MakeFakeItem(Any,Any,Any)

Paramètres: type (Any), serial (Any), count (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "makefakeitem":

                {

                    int graphic = Arg(0);

                    int serial = Arg(1, 0);

                    int amount = Arg(2, 1);

                    int hue = Arg(3, 0);

                    int x = Arg(4, bridge.GetX(bridge.Self));

                    int y = Arg(5, bridge.GetY(bridge.Self));

                    int createdSerial = bridge.CreateFakeItem(graphic, serial, amount, hue, x, y);

                    if (createdSerial == 0)

                        SystemMessage("MakeFakeItem: invalid graphic/serial or no active player.");

                    break;

                }

UO.MakeFakeItem(type, serial, count, color) — UO.MakeFakeItem(Any,Any,Any,Any)

Paramètres: type (Any), serial (Any), count (Any), color (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "makefakeitem":

                {

                    int graphic = Arg(0);

                    int serial = Arg(1, 0);

                    int amount = Arg(2, 1);

                    int hue = Arg(3, 0);

                    int x = Arg(4, bridge.GetX(bridge.Self));

                    int y = Arg(5, bridge.GetY(bridge.Self));

                    int createdSerial = bridge.CreateFakeItem(graphic, serial, amount, hue, x, y);

                    if (createdSerial == 0)

                        SystemMessage("MakeFakeItem: invalid graphic/serial or no active player.");

                    break;

                }

UO.MakeFakeItem(type, serial, count, color, x) — UO.MakeFakeItem(Any,Any,Any,Any,Any)

Paramètres: type (Any), serial (Any), count (Any), color (Any), x (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "makefakeitem":

                {

                    int graphic = Arg(0);

                    int serial = Arg(1, 0);

                    int amount = Arg(2, 1);

                    int hue = Arg(3, 0);

                    int x = Arg(4, bridge.GetX(bridge.Self));

                    int y = Arg(5, bridge.GetY(bridge.Self));

                    int createdSerial = bridge.CreateFakeItem(graphic, serial, amount, hue, x, y);

                    if (createdSerial == 0)

                        SystemMessage("MakeFakeItem: invalid graphic/serial or no active player.");

                    break;

                }

UO.MakeFakeItem(type, serial, count, color, x, y) — UO.MakeFakeItem(Any,Any,Any,Any,Any,Any)

Paramètres: type (Any), serial (Any), count (Any), color (Any), x (Any), y (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "makefakeitem":

                {

                    int graphic = Arg(0);

                    int serial = Arg(1, 0);

                    int amount = Arg(2, 1);

                    int hue = Arg(3, 0);

                    int x = Arg(4, bridge.GetX(bridge.Self));

                    int y = Arg(5, bridge.GetY(bridge.Self));

                    int createdSerial = bridge.CreateFakeItem(graphic, serial, amount, hue, x, y);

                    if (createdSerial == 0)

                        SystemMessage("MakeFakeItem: invalid graphic/serial or no active player.");

                    break;

                }

UO.MassMove

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

Signatures C#

void UO.MassMove();
void UO.MassMove(object? delay);
void UO.MassMove(object? delay, object? quantity);
void UO.MassMove(object? delay, object? quantity, object? @type);
void UO.MassMove(object? delay, object? quantity, object? @type, object? destination);
void UO.MassMove(object? delay, object? quantity, object? @type, object? destination, object? x, object? y, object? z);

Permet un transfert de masse unique d'éléments du type sélectionné. Après avoir activé MassMove, faites glisser un élément approprié avec la souris : le conteneur source en est déterminé. D'autres éléments de ce type provenant de la même source suivent automatiquement. Le troisième paramètre est TYPE/Graphic, pas le ID de l'élément. Tous les formulaires incluent l'attente du premier transfert manuel ; la destination explicite précise où il ira.

Paramètres

  • delay — Le premier paramètre est le délai entre les demandes de transfert en millisecondes, un entier compris entre 0 et 2147483647. 350 signifie 0,35 secondes. Avec 0, pas plus d'un prochain report n'est envoyé par image de jeu. Aucun délai n'est ajouté à GrabDelay. Une valeur négative désactive le mode et efface la file d'attente ; pour l'extinction, une notation claire UO.MassMove() est préférable.
  • quantity - Le deuxième paramètre est la limite TOTALE des éléments individuels (éléments), y compris le premier transfert manuel. Une pile/pile est considérée comme un article, quelle que soit la quantité à l'intérieur. 50 signifie jusqu'à 50 piles entières ou 50 éléments uniques. La pile n'est PAS divisée à cette limite. 0 ou aucun paramètre - tous les éléments appropriés. Les valeurs négatives ne sont pas autorisées.
  • type - Le troisième paramètre est le code du type d'élément (Graphique/Type), l'entier 0..65535, par exemple 0x0EED ou la chaîne "0x0EED" pour l'or. Ce n'est PAS serial/ID et PAS le nom AddObject. 0 ou absence détermine le type par le premier transfert manuel. Avec un type explicite, faire glisser un autre type n'active pas la file d'attente ; Le mode continue d'attendre un élément approprié.
  • destination — Le quatrième paramètre est le but. La série du coffre (numéro/chaîne hexadécimale) ou le nom stocké AddObject sélectionne le conteneur ; X/Y est une place à l'intérieur de sa fenêtre. backpack, self et my sélectionnent le sac à dos du personnage actuel, également avec les coordonnées à l'intérieur du sac à dos. ground ou 0 sélectionne le terrain : X/Y/Z - position absolue sur la carte, les trois paramètres sont requis. lastcontainer — dernier conteneur ouvert ; lastobject, lasttarget, lastcorpse, finditem, laststatus sont valides s'ils pointent vers un conteneur disponible. receiving et catchbag sélectionnent le conteneur SetCatchBag installé, et s'il n'est pas installé, le sac à dos. self/my signifie ici le sac à dos, bien que GetX(self) indique la position du personnage. Les noms sont comparés sans tenir compte de la casse ; un nom inconnu ou pas encore défini donne une erreur plutôt que de laisser tomber l'objet au sol. Sans destination, la localisation est mémorisée dès la première remise à zéro manuelle : vous pouvez déposer l'échantillon soit à l'intérieur du conteneur, soit au sol. Pour la terre, le monde X/Y/Z de la première réinitialisation est mémorisé.
  • x — Cinquième paramètre. Pour un conteneur, les coordonnées à l'intérieur du conteneur ; -1 ou 65535 signifie placement automatique. Pour les terres, les coordonnées absolues de la carte, de 0 à 65535. Pour un formulaire sans X/Y/Z, -1 est utilisé dans un conteneur explicite.
  • y — Sixième paramètre. Pour un conteneur - les coordonnées à l'intérieur du conteneur, -1/65535 pour le placement automatique ; pour le sol - la coordonnée absolue de la carte 0..65535. Pour un formulaire sans coordonnées dans un conteneur explicite, utilisez -1.
  • z — Le septième paramètre est la hauteur de destination, entier -128..127. Le conteneur contient généralement 0 ; au sol indiquent la hauteur réelle. Dans la forme courte, la hauteur et X/Y sont issus du transfert manuel.

Valeur de retour

void : aucune valeur. Activer MassMove signifie activer l'attente de transfert manuel. La ligne Total indique le nombre d'éléments individuels pour lesquels des demandes ont été envoyées, y compris le premier. Une pile est considérée comme un élément ; le résultat ne confirme pas l'acceptation de chaque demande par le serveur.

Comportement

  • Les formulaires avec les arguments 0, 1, 2, 3, 4 et 7 sont enregistrés. X/Y/Z sont spécifiés uniquement ensemble. Les formulaires avec les arguments 5, 6 ou 8 ne sont pas pris en charge. Commande : délai, quantité, type, destination, x, y, z.
  • Activez le mode de capture de la souris AVANT. Le premier transfert manuel est considéré comme un élément : la pile de 1000 est entièrement transférée et ne consomme qu'un seul espace de la limite 50. Le mode activé prend des piles complètes sans boîte de dialogue fractionnée. Si une partie de la pile a été prélevée avant inclusion, le transfert est refusé : remettez la partie et recommencez.
  • Une activation fait référence à un transfert manuel. Après avoir sélectionné un échantillon, le mode de sélection est désactivé ; la file d'attente restante est traitée automatiquement. Un appel normal à MoveItem depuis un autre script ne compte pas comme une sélection manuelle d'échantillons.
  • Le type Graphique est comparé. La couleur n'est pas filtrée dans cette commande. Seul le contenu direct du conteneur source est traité ; Les sacs fermés ne s'ouvrent pas. Les nouveaux éléments qui apparaissent après la création de la file d'attente n'y sont pas ajoutés. Si l'échantillon reposait au sol, les objets chargés du même type dans le rayon de capture sont pris en compte.
  • La quantité est la limite supérieure des demandes. La commande ne réessaye pas automatiquement les transferts rejetés par le serveur. Si le serveur tombe en panne, la destination n'est pas disponible, le personnage meurt ou s'il est impossible de prendre l'élément suivant, l'opération est terminée. Lorsque le curseur est occupé, la file d'attente attend jusqu'à 5 secondes pour se libérer.
  • UO.MassMove() désactive le mode et annule la file d'attente restante. UO.TerminateAll() et quitter le personnage l'annule également. Une demande déjà envoyée n'est pas annulée par annulation. La file d'attente est exécutée par le client après le retour de la commande ; la ligne suivante du script ne signifie pas que le serveur a déjà terminé le transfert.
  • Pour migrer complètement différents types de contenu, utilisez EmptyContainer. Pour transporter un objet spécifique - MoveItem. Les huit arguments source, type, couleur, destination, x, y, z, délai font référence à MoveItems, et non à MassMove.
  • Appeler correctement et à plusieurs reprises la même commande, alors que le mode attend toujours le premier glissement de la souris, désactive l'attente : Désactiver MassMove/MassPriceMove apparaît directement dans la fenêtre de jeu. L'appel suivant réactive le mode. Après le premier transfert, utilisez le formulaire sans argument pour arrêter la file d'attente restante. Les demandes déjà envoyées ne sont pas annulées.

Scripts C# autonomes

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

Exemple simple

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

La commande forme une instruction séparée. Le message précédent indique le début de l’appel et ne confirme aucune action du serveur.

UO.Print("Calling UO.MassMove");
UO.MassMove(350, 0);

1. Activer le transfert de la souris sans limiter le nombre - script direct

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

  • delay=350 : Les requêtes suivantes sont séparées d'au moins 350 ms. quantité=0 : Il n'y a pas de limite supérieure d'utilisateurs.
  • type, destination et X/Y/Z ne sont pas transmis. Après avoir activé MassMove, faites glisser l'échantillon du sac vers le coffre : le type et la source en sont extraits, la destination est celle du lieu de dépôt.
  • Si l'échantillon est de l'or, les piles d'or chargées du même conteneur d'origine sont déplacées. Les objets d'autres types restent. Print explique uniquement l'action manuelle ultérieure.
UO.MassMove(350, 0);
UO.Print("Drag one sample item to the destination container");

2. Transférer 50 des piles entières depuis 100 - fonction de script

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

  • le délai définit 350 ms. Le total est transmis au deuxième paramètre de quantité et limite l'opération ENTIÈRE 50 aux éléments individuels.
  • Si la source contient des 100 piles du même type, des 50 piles entières seront transférées : la première manuelle et une autre 49. Chaque pile peut contenir un montant différent ; cela n'affecte pas le compteur. S'il s'agit d'éléments uniques, les éléments uniques 50 sont transférés.
  • Il n'y a pas d'autres options : la première capture et l'affectation sont sélectionnées par la souris après appel.
return  RunScenario();
 object? RunScenario()
{
    var delay = 350;
    var total = 50;
    UO.MassMove(delay, total);
    return null;
}

3. Sélectionnez le type d'or et configurez le coffre à l'avance - classe de scénario

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

  • goldType - TYPE or, pas ID une pile séparée. AddObject sauvegarde serial du coffre dans le coffre ; remplacez 0x40005678 par votre ID.
  • delay=350 ms, quantité=50 articles individuels, type=0x0EED, destination=coffre. La limite inclut la première pile et pas plus de 49 ; le tout.
  • x=-1 et y=-1 définissent le placement automatique dans la poitrine, z=0. Ce sont tous les sept paramètres.
  • La file d'attente commencera après avoir fait glisser manuellement l'or. Son sac d'origine deviendra la source. Un coffre explicite remplace l'emplacement de réinitialisation de la souris ; un élément d'un autre type ne démarre pas la file d'attente.
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 goldType = "0x0EED";
        UO.AddObject("chest", "0x40005678");
        UO.MassMove(350, 50, goldType, "chest", -1, -1, 0);
        UO.Print("Now drag one gold stack from the source bag");
        return null;
    }
}

4. Sélectionnez un échantillon avec la souris, mais définissez le terrain à l'avance - script direct

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

  • delay=350 ms, quantité=0 — tous les éléments appropriés. type=0 prend le type du futur transfert manuel.
  • destination=0 signifie terre, donc le triple complet x, y, z est donné. GetX/GetY/GetZ renvoie ici la position actuelle du personnage.
  • Après avoir appelé, récupérez et déposez l'échantillon avec la souris. La commande l'enverra ainsi que les autres éléments correspondants aux coordonnées spécifiées, même si la souris était sur le conteneur. Le serveur vérifie la disponibilité du terrain.
var x = UO.GetX();
var y = UO.GetY();
var z = UO.GetZ();
UO.MassMove(350, 0, 0, 0, x, y, z);

5. Déplacez jusqu'à dix objets d'un type connu dans un sac à dos - fonction de script

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

  • delay=500 — une demi-seconde ; quantité=10 - dix éléments/piles individuels pour l'ensemble de l'opération.
  • type=0x0F7A – type graphique de l'élément. Veuillez indiquer votre type ; le numéro de série du formulaire 0x40001234 n'est pas autorisé ici.
  • destination=backpack — le sac à dos du personnage. Les coordonnées ne sont pas transmises, donc x=-1, y=-1, z=0 sont utilisés à l'intérieur.
  • La source est sélectionnée en transférant d'abord manuellement un élément approprié. Si la source est déjà un sac à dos, choisissez un autre sac source pour un transport utile.
return  RunScenario();
 object? RunScenario()
{
    UO.MassMove(500, 10, "0x0F7A", "backpack");
    UO.Print("Drag one matching item from the source chest");
    return null;
}

6. Sélectionner une place à l'intérieur d'un coffre en fonction d'un objet déjà posé - classe de scénario

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

  • Tout d’abord, placez manuellement l’objet à l’emplacement souhaité dans le coffre. Le premier AddObject sélectionne le coffre lui-même et le stocke ID dans le coffre. Le second sélectionne l'élément à l'intérieur et stocke ID dans position_sample.
  • GetX/GetY pour un élément à l'intérieur d'un conteneur renvoie ses coordonnées à l'intérieur de ce conteneur. Ils ne dépendent pas de l'endroit où se trouve la fenêtre du coffre sur l'écran.
  • delay=350 ms, quantité=50 éléments entiers, type=0 déterminé par le futur transfert manuel depuis la source, destination=chest.
  • x et y définissent l'emplacement sélectionné à l'intérieur du coffre, le dernier z=0. L'objet position_sample sert uniquement à lire les coordonnées ; la source et le type à migrer sont déterminés par une migration manuelle ultérieure.
  • Pour un sac à dos, remplacez le coffre par backpack ou self. Pour le terrain, utilisez ground et les coordonnées cartographiques telles que UO.GetX(), UO.GetY(), UO.GetZ() sans arguments pour la position actuelle du personnage.
return  new ScriptScenario(UO, WaitAsync, Args, Cancellation, Checkpoint).RunScenario();
class ScriptScenario
{
    private readonly global::ClassicUO.CSharp.CSharpGameApi UO;
    private readonly Func<int, Task> WaitAsync;
    private readonly string[] Args;
    private readonly CancellationToken Cancellation;
    private readonly Action Checkpoint;
    public ScriptScenario(global::ClassicUO.CSharp.CSharpGameApi api, Func<int, Task> wait, string[] args, CancellationToken cancellation, Action checkpoint)
    {
        UO = api;
        WaitAsync = wait;
        Args = args;
        Cancellation = cancellation;
        Checkpoint = checkpoint;
    }

     public object? RunScenario()
    {
        UO.Print("Select the destination chest");
        UO.AddObject("chest");
        UO.Print("Select an item already at the desired position inside that chest");
        UO.AddObject("position_sample");
        var x = UO.GetX("position_sample");
        var y = UO.GetY("position_sample");
        UO.MassMove(350, 50, 0, "chest", x, y, 0);
        UO.Print("Drag one source item to start the transfer");
        return null;
    }
}

7. Du coffre au sol : sélectionnez un endroit avec la souris - script direct

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

  • delay=350 — au moins 350 ms entre les requêtes suivantes. quantité=50 - jusqu'à 50 articles individuels/piles entières, y compris un échantillon ; ce ne sont pas des unités 50 de la même pile.
  • Après avoir activé MassMove, récupérez l'objet dans le coffre ouvert et placez-le au sol avec votre souris. Son type et sa poitrine originale sont déterminés par le motif ; Les destinations mondiales X/Y/Z sont mémorisées à l'emplacement de cette réinitialisation.
  • Les objets chargés restants du même type dans ce coffre sont envoyés au même point au sol. Le contenu des sacs emboîtés et autres types n'est pas affecté. Pour tous les éléments correspondants, remplacez 50 par 0.
  • MassMove n'a pas de valeur de retour. La procédure se termine une fois le mode activé, la file d'attente continue de fonctionner dans le client. Le message final compte les demandes envoyées, pas les confirmations du serveur. Pour annuler la file d'attente restante, appelez UO.MassMove().
UO.MassMove(350, 50);
UO.Print("Drag one item from the chest onto the ground");

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

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

                    if (arguments.Length == 0) bridge.MassMove(-1, 0, 0, -1, -1, -1, 0);

                    else bridge.MassMove(NumberConversions.ToInt(arguments[0]),

                        arguments.Length > 1 ? NumberConversions.ToInt(arguments[1]) : 0,

                        arguments.Length > 2 ? ResolveType(arguments[2]) : 0,

                        arguments.Length > 3 ? ResolveTransferDestination(arguments[3], true) : -1,

                        arguments.Length > 4 ? NumberConversions.ToInt(arguments[4]) : -1,

                        arguments.Length > 5 ? NumberConversions.ToInt(arguments[5]) : -1,

                        arguments.Length > 6 ? NumberConversions.ToInt(arguments[6]) : 0);

                    break;

UO.MassMove(delay) — UO.MassMove(Any)

Paramètres: delay (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "massmove":

                    if (arguments.Length == 0) bridge.MassMove(-1, 0, 0, -1, -1, -1, 0);

                    else bridge.MassMove(NumberConversions.ToInt(arguments[0]),

                        arguments.Length > 1 ? NumberConversions.ToInt(arguments[1]) : 0,

                        arguments.Length > 2 ? ResolveType(arguments[2]) : 0,

                        arguments.Length > 3 ? ResolveTransferDestination(arguments[3], true) : -1,

                        arguments.Length > 4 ? NumberConversions.ToInt(arguments[4]) : -1,

                        arguments.Length > 5 ? NumberConversions.ToInt(arguments[5]) : -1,

                        arguments.Length > 6 ? NumberConversions.ToInt(arguments[6]) : 0);

                    break;

UO.MassMove(delay, quantity) — UO.MassMove(Any,Any)

Paramètres: delay (Any), quantity (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "massmove":

                    if (arguments.Length == 0) bridge.MassMove(-1, 0, 0, -1, -1, -1, 0);

                    else bridge.MassMove(NumberConversions.ToInt(arguments[0]),

                        arguments.Length > 1 ? NumberConversions.ToInt(arguments[1]) : 0,

                        arguments.Length > 2 ? ResolveType(arguments[2]) : 0,

                        arguments.Length > 3 ? ResolveTransferDestination(arguments[3], true) : -1,

                        arguments.Length > 4 ? NumberConversions.ToInt(arguments[4]) : -1,

                        arguments.Length > 5 ? NumberConversions.ToInt(arguments[5]) : -1,

                        arguments.Length > 6 ? NumberConversions.ToInt(arguments[6]) : 0);

                    break;

UO.MassMove(delay, quantity, type) — UO.MassMove(Any,Any,Any)

Paramètres: delay (Any), quantity (Any), type (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "massmove":

                    if (arguments.Length == 0) bridge.MassMove(-1, 0, 0, -1, -1, -1, 0);

                    else bridge.MassMove(NumberConversions.ToInt(arguments[0]),

                        arguments.Length > 1 ? NumberConversions.ToInt(arguments[1]) : 0,

                        arguments.Length > 2 ? ResolveType(arguments[2]) : 0,

                        arguments.Length > 3 ? ResolveTransferDestination(arguments[3], true) : -1,

                        arguments.Length > 4 ? NumberConversions.ToInt(arguments[4]) : -1,

                        arguments.Length > 5 ? NumberConversions.ToInt(arguments[5]) : -1,

                        arguments.Length > 6 ? NumberConversions.ToInt(arguments[6]) : 0);

                    break;

UO.MassMove(delay, quantity, type, destination) — UO.MassMove(Any,Any,Any,Any)

Paramètres: delay (Any), quantity (Any), type (Any), destination (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "massmove":

                    if (arguments.Length == 0) bridge.MassMove(-1, 0, 0, -1, -1, -1, 0);

                    else bridge.MassMove(NumberConversions.ToInt(arguments[0]),

                        arguments.Length > 1 ? NumberConversions.ToInt(arguments[1]) : 0,

                        arguments.Length > 2 ? ResolveType(arguments[2]) : 0,

                        arguments.Length > 3 ? ResolveTransferDestination(arguments[3], true) : -1,

                        arguments.Length > 4 ? NumberConversions.ToInt(arguments[4]) : -1,

                        arguments.Length > 5 ? NumberConversions.ToInt(arguments[5]) : -1,

                        arguments.Length > 6 ? NumberConversions.ToInt(arguments[6]) : 0);

                    break;

UO.MassMove(delay, quantity, type, destination, x, y, z) — UO.MassMove(Any,Any,Any,Any,Any,Any,Any)

Paramètres: delay (Any), quantity (Any), type (Any), destination (Any), x (Any), y (Any), z (Any)

Résultat: void / Unit.

Pendant un appel:

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

case "massmove":

                    if (arguments.Length == 0) bridge.MassMove(-1, 0, 0, -1, -1, -1, 0);

                    else bridge.MassMove(NumberConversions.ToInt(arguments[0]),

                        arguments.Length > 1 ? NumberConversions.ToInt(arguments[1]) : 0,

                        arguments.Length > 2 ? ResolveType(arguments[2]) : 0,

                        arguments.Length > 3 ? ResolveTransferDestination(arguments[3], true) : -1,

                        arguments.Length > 4 ? NumberConversions.ToInt(arguments[4]) : -1,

                        arguments.Length > 5 ? NumberConversions.ToInt(arguments[5]) : -1,

                        arguments.Length > 6 ? NumberConversions.ToInt(arguments[6]) : 0);

                    break;

ClassicUO — Bad Newbie & C# Scripts IDE

ClassicUO — Bad Newbie & C# Scripts IDE

Clone this wiki locally