FR UO Topic scripts runtime

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

Scripts et exécution

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

Démarrez, mettez en pause, arrêtez les scripts et les procédures, les informations sur les instances, les événements et attendez. Terminate et StopScript fonctionnent à différents niveaux d'exécution.

Sections

Sujet	Commandes et explications
StartScript	UO.StartScript
StopScript	UO.StopScript
StopAllScripts	UO.StopAllScripts
PauseResumeScript	UO.PauseResumeScript
Script State	UO.GetScriptState
Script List	UO.GetScriptsList · UO.GetScriptsCount
Script Name	UO.GetScriptName · UO.SetScriptName
Script Path	UO.GetScriptPath
CallSub	UO.CallSub
SubExists	UO.SubExists
Events	UO.SetEvent · UO.SetEventProc
Timers	UO.Timer · UO.Wait
Disconnect Behaviour	UO.GetPauseScriptOnDisconnectStatus · UO.SetPauseScriptOnDisconnectStatus

Toutes les commandes du thème

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

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

var indices = UO.GetScriptsList();
foreach (var index in indices)
{
    UO.Print(Convert.ToString(index) + ": " + UO.GetScriptName(index));
}

UO.TerminateAll

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

for (int cycle = (int)(1); cycle <= 10; cycle += (int)(1))
{
    if (Truth(UO.Dead()))
    {
        UO.Print("Character is dead: stopping all C# scripts");
        UO.TerminateAll();
    }
    await Delay(250);
}

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;

Référence complète des commandes

UO.CallSub

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

Signatures C#

void UO.CallSub(object? subrutineName);

Lance le délégué C# précédemment enregistré dans l'exécution en cours via RegisterRoutine(nom, gestionnaire). L'appel rend le contrôle avant que l'assistant ne termine ; Une tâche enregistrée ne peut s'imposer à elle-même.

Paramètres

subrutineName est le nom de chaîne donné par RegisterRoutine. Les espaces autour des bords sont supprimés ; Les recherches de noms enregistrés ne sont pas sensibles à la casse.

Valeur de retour

void - aucun résultat ; un nom inconnu CallSub provoque une erreur et la réexécution d'un nom déjà actif est ignorée.

Comportement

UO.FunRunning(name) == 0 peut aussi apparaître immédiatement après une demande d’annulation. Cela ne signifie pas que le callback précédent a terminé son bloc finally. Un autre CallSub ou Exec portant le même nom local est ignoré jusqu’à la fin réelle du worker précédent.

L'inscription et les tâches appartiennent à la même exécution. Un autre personnage, profil ou exécution ultérieure possède son propre registre.
RegisterRoutine accepte Action, Func<Task> ou un délégué avec un tableau d'arguments de chaîne pour Exec. La suppression de l'enregistrement n'exécute pas le code et empêche toute recherche ultérieure du nom.
Le script principal doit rester actif tant que ses assistants sont nécessaires : une fois terminé, les tâches sont annulées et les inscriptions et abonnements sont libérés.
FunRunning n'est pas un index de gestionnaire. GetScriptsList et GetScriptState décrivent des lancements de fichiers indépendants ; le rappel local ne reçoit pas d'index séparé.
L'erreur de rappel est transmise au script principal lors de la prochaine vérification. Les boucles WaitAsync, UO.Wait et instrumentées C# prennent en charge la pause, l'annulation et le traitement de la file d'attente d'événements.

Fichiers C# téléchargés

En plus des délégués locaux, le gestionnaire actuel prend en charge les entrées C# explicitement chargées avec une clé comme Child.csx::Main. SubExists et FunRunning acceptent une telle clé ; CallSub exécute le fichier sans Args, et Exec("exec Child.csx::Main 'north gate' 42") passe Args. La clé avec des espaces est entourée de guillemets à l'intérieur de Exec. Un nom court unique est acceptable, un nom ambigu ne sélectionne pas un fichier au hasard. L'inscription locale est prioritaire. Un lancement de fichier a son propre contexte et sa propre durée de vie dans le monde/gestionnaire actuel ; les délégués locaux appartiennent à l'exécution qui les a inscrits.

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.

RegisterRoutine("Hello", () => UO.Print("Hello from a routine"));
UO.CallSub("Hello");
while (UO.FunRunning("Hello") != 0) await WaitAsync(25);

1. Démarrez l'observateur et continuez Main - script direct

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

WeightWatch est le nom de la procédure ci-dessous. Main renvoie 77 sans attendre trois échantillons ; 77 est le résultat de Main, pas CallSub.
Enregistrez l'exemple dans un fichier séparé, chargez-le dans IDE/manager et exécutez Main pour que le reste des procédures se retrouve dans le répertoire. WeightWatch/ManaWatch - procédures d'entraînement entièrement définies ici : trois mesures poids/mana avec un intervalle de UO.Wait(1000), c'est-à-dire 1000 ms, sorties uniquement à l'entrée dans le monde. Il ne s’agit pas d’une surveillance continue ; une pause peut prolonger le temps. Pour l'exemple avec deux tâches, le lancement simultané de procédures doit être autorisé.

var registrationWeightWatch = RegisterRoutine("WeightWatch", WeightWatch);
UO.CallSub("WeightWatch");
while (UO.FunRunning("WeightWatch") != 0) await WaitAsync(25);
return 77;

void WeightWatch()
{
    dynamic sample = 0;
    for (sample = (int)(1); sample <= 3; sample += (int)(1))
    {
        if (Truth(UO.Connected()))
        {
            UO.Print("Weight: " + Convert.ToString(UO.Weight()));
        }
        UO.Wait(1000);
    }
}

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

2. Ne pas redémarrer une tâche active ou suspendue - fonction script

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

StartIfIdle vérifie d'abord la définition, puis l'activité. false signifie que la demande n'a pas été envoyée. true signifie que seule la demande CallSub a été envoyée, et non la confirmation du début ou de l'achèvement.
Enregistrez l'exemple dans un fichier séparé, chargez-le dans IDE/manager et exécutez Main pour que le reste des procédures se retrouve dans le répertoire. WeightWatch/ManaWatch - procédures d'entraînement entièrement définies ici : trois mesures poids/mana avec un intervalle de UO.Wait(1000), c'est-à-dire 1000 ms, sorties uniquement à l'entrée dans le monde. Il ne s’agit pas d’une surveillance continue ; une pause peut prolonger le temps. Pour l'exemple avec deux tâches, le lancement simultané de procédures doit être autorisé.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var registrationWeightWatch = RegisterRoutine("WeightWatch", WeightWatch);
    var launched = StartIfIdle("WeightWatch");
    while (UO.FunRunning("WeightWatch") != 0)
        await WaitAsync(25);
    return launched;
    return null;
}

dynamic StartIfIdle(dynamic name)
{
    if (!(Truth(UO.SubExists(name))))
    {
        return false;
    }

    if (Truth(UO.FunRunning(name)))
    {
        return false;
    }

    UO.CallSub(name);
    return true;
}

void WeightWatch()
{
    dynamic sample = 0;
    for (sample = (int)(1); sample <= 3; sample += (int)(1))
    {
        if (Truth(UO.Connected()))
        {
            UO.Print("Weight: " + Convert.ToString(UO.Weight()));
        }

        UO.Wait(1000);
    }
}

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

3. Deux observateurs indépendants - Classe de scénario

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

Le premier CallSub commence par WeightWatch, le second - ManaWatch. Les exécutions sont indépendantes et n'échangent pas de variables locales ; l'ordre de leur sortie n'est pas garanti.
Enregistrez l'exemple dans un fichier séparé, chargez-le dans IDE/manager et exécutez Main pour que le reste des procédures se retrouve dans le répertoire. WeightWatch/ManaWatch - procédures d'entraînement entièrement définies ici : trois mesures poids/mana avec un intervalle de UO.Wait(1000), c'est-à-dire 1000 ms, sorties uniquement à l'entrée dans le monde. Il ne s’agit pas d’une surveillance continue ; une pause peut prolonger le temps. Pour l'exemple avec deux tâches, le lancement simultané de procédures doit être autorisé.

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 registrationWeightWatch = RegisterRoutine("WeightWatch", WeightWatch);
        var registrationManaWatch = RegisterRoutine("ManaWatch", ManaWatch);
        UO.CallSub("WeightWatch");
        UO.CallSub("ManaWatch");
        while (UO.FunRunning("WeightWatch") != 0 || UO.FunRunning("ManaWatch") != 0)
            await WaitAsync(25);
        return null;
    }

    void WeightWatch()
    {
        dynamic sample = 0;
        for (sample = (int)(1); sample <= 3; sample += (int)(1))
        {
            if (Truth(UO.Connected()))
            {
                UO.Print("Weight: " + Convert.ToString(UO.Weight()));
            }

            UO.Wait(1000);
        }
    }

    void ManaWatch()
    {
        dynamic sample = 0;
        for (sample = (int)(1); sample <= 3; sample += (int)(1))
        {
            if (Truth(UO.Connected()))
            {
                UO.Print("Mana: " + Convert.ToString(UO.Mana()));
            }

            UO.Wait(1000);
        }
    }

    bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
    private IDisposable RegisterRoutine(string name, Action handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Action<string[]> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<string[], Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
}

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.CallSub(subrutineName)` — `UO.CallSub(String)`

Paramètres: subrutineName (String)

Résultat: void / Unit.

Pendant un appel:

ClassicUO.CSharp.CSharpCallbacks.TryInvoke.
InjectionScript.Runtime.InjectionApiUO.CallSub.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Exec: bridge.Exec(subrutineName).

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

case "CallSub":
                string called = Convert.ToString(arguments[0]) ?? "";
                if (Exists(called)) Start(called);
                else if (events is ICSharpScriptHost host && host.HasCSharpScript(called)) host.ExecuteCSharpScript("exec \"" + called + "\"");
                else throw new ArgumentException($"Register the C# routine or load a C# script entry named '{called}' before calling it.");
                return true;

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

public void CallSub(string subrutineName) => bridge.Exec(subrutineName);

UO.Date

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

Signatures C#

int UO.Date();

Lit la date du calendrier local de l'ordinateur avec le numéro YYMMDD. Utile pour nommer une série d’activités quotidiennes ou détecter des changements de date.

Paramètres

Il n'y a pas de paramètres.

Valeur de retour

int YYMMDD : 2026-09-30 -> 260930. Aucun délimiteur ni zéro non significatif n'est stocké. Ce n'est pas la durée, ce n'est pas l'heure Unix, et ce n'est pas true/false.

Comportement

Il n'y a pas de paramètres, pas de formulaires avec arguments. Les parenthèses vides ne lisent que l'heure : l'appel n'attend pas, ne démarre pas de chronomètre et n'envoie pas de paquets au jeu.
RealTimeSource.Lit maintenant DateTime.Maintenant : la date/heure locale de l'ordinateur, pas UTC, ni l'heure du fragment, ni l'horloge du jeu. Le fuseau horaire, l’heure d’été et le changement manuel de l’horloge affectent les résultats. Chaque appel capture un moment différent.
Seuls les deux derniers chiffres de l'année sont conservés : les deux 2000-01-01 et 2100-01-01 donnent 101. Les différents siècles ne sont pas différents. Les appels individuels Date et Time peuvent atterrir du côté opposé de minuit.
Ne soustrayez pas les codes de calendrier pour calculer le retard. Utilisez Timer() et deux marques d'une exécution. L'horloge du calendrier peut revenir en arriè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.Date();
UO.Print("Date: " + Convert.ToString(result));

1. Nommez la série de collecte de ressources quotidiennes - script direct

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

Le résultat de l'appel sans paramètres est enregistré une fois. sessionLabel est une chaîne comme Harvest-260930. Print affiche uniquement le nom : le fichier n'est pas créé, la collecte des ressources ne démarre pas.

var dateStamp = UO.Date();
var sessionLabel = "harvest-" + Convert.ToString(dateStamp);
UO.Print(sessionLabel);

2. Terminer la série lorsque le jour local change - fonction script

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

originalDate stocke la date d'origine. Timer limite l'observation à 60 secondes, UO.Wait(1000) vérifie environ une fois par seconde. Changer la date termine Main. L'exemple n'attend pas indéfiniment minuit et ne prétend pas que le jour a changé sur le serveur.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var originalDate = UO.Date();
    var started = Environment.TickCount;
    while (Truth(Environment.TickCount - started < 60.0))
    {
        if (Truth(UO.Date() != originalDate))
        {
            UO.Print("Local date changed; end this batch");
            return null;
        }

        await Delay(1000);
    }

    UO.Print("No date change observed within one minute");
    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. Sélectionnez l'année, le mois et le jour - classe de script

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

MonthPart(timbre) est affiché dans son intégralité : division arrondie et MOD 100 extrait le mois. jour : les deux derniers chiffres ; shortYear—année incomplète. Pour 260930 nous obtenons 26, 9, 30.

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 stamp = UO.Date();
        var month = MonthPart(stamp);
        var day = stamp % 100;
        var shortYear = stamp / 10000;
        UO.Print(Convert.ToString(shortYear) + "/" + Convert.ToString(month) + "/" + Convert.ToString(day));
        return null;
    }

    dynamic MonthPart(dynamic stamp)
    {
        return stamp / 100 % 100;
    }
}

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

Paramètres: Aucun paramètre.

Résultat: int / Integer.

Pendant un appel:

InjectionScript.Runtime.InjectionApiUO.Date.

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

public int Date()

        {

            var now = timeSource.Now;

            return (now.Year % 100) * 10000 + now.Month * 100 + now.Day;

        }

UO.Exec

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

Signatures C#

void UO.Exec(object? parameters);

Exécute une commande de jeu de texte ou exécute un délégué C# enregistré ou un fichier C# chargé.

Paramètres

parameters - chaîne de commande : par exemple, "useskill Hiding", "exec Worker 42" ou "exec Child.csx::Main 'north gate' 42". Une expression C# comme 2+3 à l'intérieur d'une chaîne n'est pas automatiquement évaluée.

Valeur de retour

void : aucun résultat. La restitution du contrôle ne signifie pas la fin du lancement ni la confirmation de l'action du jeu par le serveur.

Comportement

UO.FunRunning(name) == 0 peut aussi apparaître immédiatement après une demande d’annulation. Cela ne signifie pas que le callback précédent a terminé son bloc finally. Un autre CallSub ou Exec portant le même nom local est ignoré jusqu’à la fin réelle du worker précédent.

Le registre local RegisterRoutine est vérifié en premier. "Name args", "exec Name args" et "_exec Name args" sont pris en charge. Le délégué reçoit string[] : l'argument 42 reste la chaîne "42", et '00123' conserve les zéros non significatifs. Les guillemets simples ou doubles concatènent un argument avec des espaces ; '' spécifie une chaîne vide. Un devis non fermé provoque une erreur. Dans cet itinéraire, la barre oblique inverse est conservée littéralement ; N'utilisez pas la syntaxe d'échappement C# dans le texte de commande pré-écrit.
Le délégué local s'exécute de manière asynchrone. Pour attendre la fin, utilisez FunRunning et WaitAsync. Le redémarrage du nom actif ne crée pas de copie et ne supprime pas la pause. L'erreur d'assistance est transmise au script principal au point de contrôle.
Les entrées de fichier explicitement chargées sont démarrées par le gestionnaire actuel avec son propre Args et sa propre durée de vie. Le simple fait d'accepter la demande de lancement ne signifie pas que le fichier a fini de fonctionner.
Les commandes de jeu régulières sont transmises au répartiteur natif. Les contrats de paramètres de la commande UO correspondante y sont stockés ; Print/Msg/Say/ConsolePrint/TextPrint combinent le reste de la ligne en texte. Pour les types et expressions C# précis, utilisez un appel direct comme UO.UseSkill("Hiding"). Une commande inconnue, des arguments non valides ou des guillemets peuvent provoquer l'interception d'une exception par try/catch.
Alias de console : sayu → Say, closeuo → CloseHandle, CountOnGround → CountGround, clearignorelist → IgnoreReset, Canceltarget → CancelTarget, Cancelmove → MoveOff.

Fichiers C# téléchargés

En plus des délégués locaux, le gestionnaire actuel prend en charge les entrées C# explicitement chargées avec une clé comme Child.csx::Main. SubExists et FunRunning acceptent une telle clé ; CallSub exécute le fichier sans Args, et Exec("exec Child.csx::Main 'north gate' 42") passe Args. La clé avec des espaces est entourée de guillemets à l'intérieur de Exec. Un nom court unique est acceptable, un nom ambigu ne sélectionne pas un fichier au hasard. L'inscription locale est prioritaire. Un lancement de fichier a son propre contexte et sa propre durée de vie dans le monde/gestionnaire actuel ; les délégués locaux appartiennent à l'exécution qui les a inscrits.

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.

RegisterRoutine("Hello", () => UO.Print("Hello from a routine"));
UO.Exec("exec Hello");
while (UO.FunRunning("Hello") != 0) await WaitAsync(25);

1. Utiliser la compétence sélectionnée - script direct

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

Se cacher est le seul argument de UseSkill. En entrant dans le monde, le client envoie une demande pour utiliser la compétence ; le succès de la dissimulation est déterminé par le serveur. Même opération par appel direct : UO.UseSkill("Hiding").

UO.Exec("useskill Hiding");

2. Passer l'étiquette de chaîne à la procédure locale - fonction de script

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

SelectSavedRoute est défini ci-dessous et enregistre le nom de l'itinéraire sélectionné. Les guillemets autour de 00123 conservent les zéros non significatifs. Exec exécute le délégué enregistré de manière asynchrone. La boucle avec FunRunning et WaitAsync attend explicitement qu'elle se termine, puis le script renvoie la chaîne 00123. Il s'agit d'une sauvegarde du nom d'entraînement, pas d'une commande de mouvement.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var registration = RegisterRoutine("SelectSavedRoute", (Action<string[]>)(arguments =>
    {
        if (arguments.Length == 1)
            SelectSavedRoute(arguments[0]);
    }));
    UO.Exec("SelectSavedRoute '00123'");
    while (UO.FunRunning("SelectSavedRoute") != 0)
        await WaitAsync(25);
    return UO.GetGlobal("manual", "savedRoute");
    return null;
}

void SelectSavedRoute(dynamic name)
{
    UO.SetGlobal("manual", "savedRoute", name);
}

3. Exécuter un observateur séparé - Classe de script

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

Exécutez ce script C# : RegisterRoutine associe le nom WeightWatch à la fonction déclarée de l'exécution en cours. exec WeightWatch démarre trois mesures de poids à intervalles 1000 ms et n'attend pas qu'elles se terminent. Le script principal reste actif pendant l'exécution de l'assistant local ; L'assistant ne dispose pas d'un index de gestionnaire distinct. Si la tâche est déjà en pause, Exec ne la reprend pas.

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 registrationWeightWatch = RegisterRoutine("WeightWatch", WeightWatch);
        UO.Exec("exec WeightWatch");
        while (UO.FunRunning("WeightWatch") != 0)
            await WaitAsync(25);
        return null;
    }

    void WeightWatch()
    {
        dynamic sample = 0;
        for (sample = (int)(1); sample <= 3; sample += (int)(1))
        {
            if (Truth(UO.Connected()))
            {
                UO.Print("Weight: " + Convert.ToString(UO.Weight()));
            }

            UO.Wait(1000);
        }
    }

    bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
    private IDisposable RegisterRoutine(string name, Action handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Action<string[]> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<string[], Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
}

4. Charger le script à partir du dossier avec des espaces - script direct

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

Remplacez le chemin par le fichier C# existant par votre procédure principale. startscript charge le fichier et demande à Main de s'exécuter. Les guillemets appartiennent à la commande text ; les barres obliques inverses du chemin sont conservées. Voir IDE pour les erreurs de démarrage, car Exec ne renvoie pas d'accusé de réception.

UO.Exec("startscript 'C:\\UO Scripts\\Gather.csx'");

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.Exec(parameters)` — `UO.Exec(String)`

Paramètres: parameters (String)

Résultat: void / Unit.

Pendant un appel:

ClassicUO.CSharp.CSharpCallbacks.TryInvoke.
InjectionScript.Runtime.InjectionRuntime.Exec.
InjectionScript.Runtime.InjectionRuntime.Tokenize: Tokenize(parameters).
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Exec: bridge.Exec(parts[1].Text).
InjectionScript.Runtime.InjectionRuntime.TryHandleLegacyConsoleCommand: TryHandleLegacyConsoleCommand(command, rawArguments).
InjectionScript.Runtime.InjectionRuntime.NormalizeConsoleAlias: NormalizeConsoleAlias(command).
InjectionScript.Runtime.InjectionRuntime.IsRemainderTextCommand: IsRemainderTextCommand(command).
InjectionScript.Runtime.InjectionRuntime.ToConsoleValue: ToConsoleValue(token.Text).
InjectionScript.Runtime.InjectionRuntime.CallNativeSubrutine: CallNativeSubrutine(command, args).

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

case "Exec":
                var words = CommandWords(Convert.ToString(arguments[0]) ?? "");
                if (words.Length == 0) return false;
                int offset = words[0].Equals("exec", StringComparison.OrdinalIgnoreCase) || words[0].Equals("_exec", StringComparison.OrdinalIgnoreCase) ? 1 : 0;
                if (words.Length > offset && Exists(words[offset]))
                { Start(words[offset], words.Skip(offset + 1).ToArray()); return true; }
                if (words.Length > offset && events is ICSharpScriptHost scriptHost
                    && (offset == 1 || scriptHost.HasCSharpScript(words[offset])))
                {
                    string command = Convert.ToString(arguments[0]) ?? "";
                    if (words[0].Equals("_exec", StringComparison.OrdinalIgnoreCase)) command = "exec" + command.TrimStart()[5..];
                    scriptHost.ExecuteCSharpScript(command); return true;
                }
                return false;

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

public void Exec(string parameters)
        {
            ConsoleToken[] parts = Tokenize(parameters).ToArray();
            if (parts.Length == 0)
                return;

            string command = parts[0].Text;
            if (command.Equals("exec", StringComparison.OrdinalIgnoreCase))
            {
                if (parts.Length != 2 || string.IsNullOrWhiteSpace(parts[1].Text))
                    throw new NativeSubrutineException("Usage: exec script_function");
                bridge.Exec(parts[1].Text);
                return;
            }

            ConsoleToken[] arguments = parts.Skip(1).ToArray();
            string[] rawArguments = arguments.Select(token => token.Text).ToArray();
            if (TryHandleLegacyConsoleCommand(command, rawArguments))
                return;

            command = NormalizeConsoleAlias(command);
            if (IsRemainderTextCommand(command) && rawArguments.Length > 0)
                arguments = new[] { new ConsoleToken(string.Join(" ", rawArguments), true) };
            else if (command.Equals("ColorPrint", StringComparison.OrdinalIgnoreCase) && rawArguments.Length > 1)
                arguments = new[] { arguments[0], new ConsoleToken(string.Join(" ", rawArguments.Skip(1)), true) };
            else if (command.Equals("CharPrint", StringComparison.OrdinalIgnoreCase) && rawArguments.Length > 2)
                arguments = new[] { arguments[0], arguments[1], new ConsoleToken(string.Join(" ", rawArguments.Skip(2)), true) };

            InjectionValue[] args = arguments.Select(token => token.Quoted
                ? new InjectionValue(token.Text) : ToConsoleValue(token.Text)).ToArray();
            CallNativeSubrutine(command, args);
        }

UO.FunRunning

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

Signatures C#

int UO.FunRunning(object? subrutineName);

Vérifie si le rappel C# enregistré avec le nom spécifié est exécuté. Le résultat 1 active la pause manuelle ; une tâche terminée ou annulée donne 0.

Paramètres

subrutineName est le nom de chaîne donné par RegisterRoutine. Les espaces autour des bords sont supprimés ; Les recherches de noms enregistrés ne sont pas sensibles à la casse.

Valeur de retour

int : 1 - la condition est remplie, 0 - non remplie. Enregistrez le résultat d'un appel si plusieurs vérifications en ont besoin.

Comportement

UO.FunRunning(name) == 0 peut aussi apparaître immédiatement après une demande d’annulation. Cela ne signifie pas que le callback précédent a terminé son bloc finally. Un autre CallSub ou Exec portant le même nom local est ignoré jusqu’à la fin réelle du worker précédent.

L'inscription et les tâches appartiennent à la même exécution. Un autre personnage, profil ou exécution ultérieure possède son propre registre.
RegisterRoutine accepte Action, Func<Task> ou un délégué avec un tableau d'arguments de chaîne pour Exec. La suppression de l'enregistrement n'exécute pas le code et empêche toute recherche ultérieure du nom.
Le script principal doit rester actif tant que ses assistants sont nécessaires : une fois terminé, les tâches sont annulées et les inscriptions et abonnements sont libérés.
FunRunning n'est pas un index de gestionnaire. GetScriptsList et GetScriptState décrivent des lancements de fichiers indépendants ; le rappel local ne reçoit pas d'index séparé.
L'erreur de rappel est transmise au script principal lors de la prochaine vérification. Les boucles WaitAsync, UO.Wait et instrumentées C# prennent en charge la pause, l'annulation et le traitement de la file d'attente d'événements.

Fichiers C# téléchargés

En plus des délégués locaux, le gestionnaire actuel prend en charge les entrées C# explicitement chargées avec une clé comme Child.csx::Main. SubExists et FunRunning acceptent une telle clé ; CallSub exécute le fichier sans Args, et Exec("exec Child.csx::Main 'north gate' 42") passe Args. La clé avec des espaces est entourée de guillemets à l'intérieur de Exec. Un nom court unique est acceptable, un nom ambigu ne sélectionne pas un fichier au hasard. L'inscription locale est prioritaire. Un lancement de fichier a son propre contexte et sa propre durée de vie dans le monde/gestionnaire actuel ; les délégués locaux appartiennent à l'exécution qui les a inscrits.

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.

RegisterRoutine("Hello", async () => await WaitAsync(100));
UO.CallSub("Hello");
UO.Print("Running flag: " + UO.FunRunning("Hello"));
while (UO.FunRunning("Hello") != 0) await WaitAsync(25);

1. Exécuter un observateur enregistré sans superposition - script direct

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

Premièrement, RegisterRoutine associe le nom à la fonction C#. FunRunning vérifie la tâche de cette exécution, y compris la pause. Le script principal reste actif jusqu'à ce que l'assistant termine.

var registration = RegisterRoutine("WeightWatch", WatchWeight);
if (UO.FunRunning("WeightWatch") == 0) UO.CallSub("WeightWatch");
while (UO.FunRunning("WeightWatch") != 0) await WaitAsync(25);

async Task WatchWeight()
{
    for (int sample = 0; sample < 3; sample++)
    {
        UO.Print($"Weight: {UO.Weight()}");
        await WaitAsync(250);
    }
}

2. Attendez la fin et lisez le résultat du travail en arrière-plan - fonction de script

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

Le délégué asynchrone modifie le compteur partagé via Interlocked. Après FunRunning=0 le résultat est lu via Volatile. Il s'agit d'un rappel local ; il n'a pas d'index séparé GetScriptsList.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    int completed = 0;
    var registration = RegisterRoutine("Worker", async () =>
    {
        await WaitAsync(150);
        Interlocked.Exchange(ref completed, 1);
    });
    UO.CallSub("Worker");
    UO.Print($"Worker active: {UO.FunRunning("Worker") != 0}");
    while (UO.FunRunning("Worker") != 0)
        await WaitAsync(25);
    return Volatile.Read(ref completed) == 1;
    return null;
}

3. Annuler l'assistant asynchrone enregistré - classe de script

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

Terminate sélectionne la tâche enregistrée de l'exécution en cours. En attente que WaitAsync utilise son jeton d'annulation. finally effectue le nettoyage ; d'autres actions de jeu de la tâche annulée ne sont pas autorisées.

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()
    {
        int cleanupDone = 0;
        var registration = RegisterRoutine("Worker", async () =>
        {
            try
            {
                await WaitAsync(5000);
            }
            finally
            {
                Interlocked.Exchange(ref cleanupDone, 1);
            }
        });
        UO.CallSub("Worker");
        await WaitAsync(100);
        if (UO.FunRunning("Worker") != 0)
            UO.Terminate("Worker");
        while (UO.FunRunning("Worker") != 0)
            await WaitAsync(25);
        while (Volatile.Read(ref cleanupDone) == 0)
            await WaitAsync(25);
        return true;
        return null;
    }

    private IDisposable RegisterRoutine(string name, Action handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Action<string[]> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<string[], Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
}

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.FunRunning(subrutineName)` — `UO.FunRunning(String)`

Paramètres: subrutineName (String)

Résultat: int / Integer.

Pendant un appel:

ClassicUO.CSharp.CSharpCallbacks.TryInvoke.
InjectionScript.Runtime.InjectionApiUO.FunRunning.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.FunRunning: bridge.FunRunning(subrutineName).

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

case "FunRunning":
                string runningName = Convert.ToString(arguments[0]) ?? "";
                result = IsRunning(runningName) || events is ICSharpScriptHost runningHost && runningHost.IsCSharpScriptRunning(runningName) ? 1 : 0;
                return true;

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

public int FunRunning(string subrutineName) => bridge.FunRunning(subrutineName) ? 1 : 0;

UO.GetPauseScriptOnDisconnectStatus

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

Signatures C#

dynamic UO.GetPauseScriptOnDisconnectStatus();

Lit le paramètre de pause du script lorsque le gestionnaire est désactivé.

Paramètres

Il n'y a pas de paramètres.

Valeur de retour

int 1 — PauseScriptsOnDisconnect activé ; 0 - désactivé.

Comportement

Lit l'indicateur du gestionnaire, pas la pause actuelle d'un script individuel. L'appel lui-même ne se met pas en pause ou ne reprend pas la pause.

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

1. Paramètres de lecture - script direct

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

La valeur décrit le paramètre du gestionnaire.

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

2. Vérifiez séparément la connexion - fonction de script

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

L'indicateur de configuration et la connexion sont lus indépendamment.

return  RunScenario();
 object? RunScenario()
{
    var pauseOnDisconnect = UO.GetPauseScriptOnDisconnectStatus();
    var online = UO.Connected();
    UO.Print(Convert.ToString(pauseOnDisconnect) + " " + Convert.ToString(online));
    return null;
}

3. Enregistrer la valeur - Classe de script

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

La variable contient un instantané du paramètre au moment de la lecture.

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 saved = UO.GetPauseScriptOnDisconnectStatus();
        await Delay(100);
        UO.Print(Convert.ToString(saved));
        return null;
    }

    Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));
}

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

Paramètres: Aucun paramètre.

Résultat: dynamic / Any.

Pendant un appel:

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

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

case "getpausescriptondisconnectstatus": return new InjectionValue(bridge.GetPauseScriptOnDisconnectStatus());

UO.GetScriptName

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

Signatures C#

string UO.GetScriptName(object? scriptIndex);

Lit le nom d’affichage de l’exécution active.

Paramètres

scriptIndex - Obligatoire ScriptIndex - entier, index à partir de zéro à partir du nouveau GetScriptsList. Pour un index négatif ou manquant, le résultat vide/inconnu décrit est renvoyé. Ne passez pas le serial du sujet, le nom de la procédure, ou le ID du lancement depuis le IDE.

Valeur de retour

string : nom d'affichage ou "" s'il n'y a pas d'index. Un lancement existant peut également avoir son nom explicitement défini sur une chaîne vide.

Comportement

Les lancements en cours et en pause sont pris en compte ; ceux complétés et ayant reçu une demande d’annulation sont exclus. Un script en cours d'exécution prend généralement en compte lui-même. Le simple chargement de l'onglet IDE n'est pas considéré comme un lancement.
Les index sont les positions actuelles dans l'ordre de démarrage. Le démarrage/arrêt des scripts peut changer de position. Différents appels ne forment pas un instantané atomique commun ; relisez la liste avant la prochaine commande de contrôle.
GetScriptsList donne les indices, GetScriptsCount la quantité, GetScriptState le code à trois états. Ne remplacez pas l'un par l'autre et ne traitez pas tout résultat non nul comme la valeur de true.
ScriptIndex=0 - le premier lancement en cours, n'appelant pas nécessairement le script. SetScriptName modifie le nom d'affichage sans renommer le fichier.

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

1. Premier appel et résultat - script direct

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

Exécutez le script C# donné. Le nombre 0, là où il est passé, désigne l'index ; les parenthèses vides signifient aucun argument. Le texte Print est uniquement un exemple de message.
ScriptIndex=0 - le premier lancement en cours, n'appelant pas nécessairement le script. SetScriptName modifie le nom d'affichage sans renommer le fichier.
string : nom d'affichage ou "" s'il n'y a pas d'index. Un lancement existant peut également avoir son nom explicitement défini sur une chaîne vide.
Obligatoire ScriptIndex est un entier, index à partir de zéro à partir du nouveau GetScriptsList. Pour un index négatif ou manquant, le résultat vide/inconnu décrit est renvoyé. Ne passez pas le serial de la rubrique, le nom de la procédure, ni le ID du lancement depuis le IDE.

var index = 0;
var name = UO.GetScriptName(index);
UO.Print(name);

2. Utilisation dans une boucle ou une condition - fonction script

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

Il s'agit d'un exemple spécifique de partage de commandes. L'indexation des tableaux commence à zéro ; Veuillez vérifier la longueur avant manipulation. UO.Wait(250), là où il est utilisé, attend 250 millisecondes.
ScriptIndex=0 - le premier lancement en cours, n'appelant pas nécessairement le script. SetScriptName modifie le nom d'affichage sans renommer le fichier.
string : nom d'affichage ou "" s'il n'y a pas d'index. Un lancement existant peut également avoir son nom explicitement défini sur une chaîne vide.
Obligatoire ScriptIndex est un entier, index à partir de zéro à partir du nouveau GetScriptsList. Pour un index négatif ou manquant, le résultat vide/inconnu décrit est renvoyé. Ne passez pas le serial de la rubrique, le nom de la procédure, ni le ID du lancement depuis le IDE.

return  RunScenario();
 object? RunScenario()
{
    var indices = UO.GetScriptsList();
    foreach (var index in indices)
    {
        var name = UO.GetScriptName(index);
        UO.Print(Convert.ToString(index) + " = " + name);
    }

    return null;
}

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

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

Sous Main se trouve la fonction entière. Ses paramètres et son résultat sont expliqués séparément de la commande API qu'il appelle.
DescribeScript vérifie l'état et concatène le nom avec le chemin. Une pause entre les appels est possible ; "manquant" est la valeur de notre fonction, pas le résultat de GetScriptName.
string : nom d'affichage ou "" s'il n'y a pas d'index. Un lancement existant peut également avoir son nom explicitement défini sur une chaîne vide.
Obligatoire ScriptIndex est un entier, index à partir de zéro à partir du nouveau GetScriptsList. Pour un index négatif ou manquant, le résultat vide/inconnu décrit est renvoyé. Ne passez pas le serial de la rubrique, le nom de la procédure, ni le ID du lancement depuis le IDE.

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

    dynamic DescribeScript(dynamic index)
    {
        if (Truth(UO.GetScriptState(index) == 0))
        {
            return "missing";
        }

        return UO.GetScriptName(index) + " | " + UO.GetScriptPath(index);
    }

    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.GetScriptName(scriptIndex)` — `UO.GetScriptName(Any)`

Paramètres: scriptIndex (Any)

Résultat: string / String.

Pendant un appel:

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

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

case "getscriptname": return new InjectionValue(bridge.GetScriptName(Arg(0)));

UO.GetScriptPath

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

Signatures C#

string UO.GetScriptPath(object? scriptIndex);

Lit le chemin du fichier source de démarrage actif.

Paramètres

scriptIndex - Obligatoire ScriptIndex - entier, index à partir de zéro à partir du nouveau GetScriptsList. Pour un index négatif ou manquant, le résultat vide/inconnu décrit est renvoyé. Ne passez pas le serial du sujet, le nom de la procédure, ou le ID du lancement depuis le IDE.

Valeur de retour

string : chemin enregistré du fichier source ou "" s'il n'y a pas d'index. Lors de l'exécution du fichier, il s'agit généralement du chemin complet ; La commande ou la source peut ne pas avoir de fichier normal en mémoire.

Comportement

Les lancements en cours et en pause sont pris en compte ; ceux complétés et ayant reçu une demande d’annulation sont exclus. Un script en cours d'exécution prend généralement en compte lui-même. Le simple chargement de l'onglet IDE n'est pas considéré comme un lancement.
Les index sont les positions actuelles dans l'ordre de démarrage. Le démarrage/arrêt des scripts peut changer de position. Différents appels ne forment pas un instantané atomique commun ; relisez la liste avant la prochaine commande de contrôle.
GetScriptsList donne les indices, GetScriptsCount la quantité, GetScriptState le code à trois états. Ne remplacez pas l'un par l'autre et ne traitez pas tout résultat non nul comme la valeur de true.
ScriptIndex=0 sélectionne la première exécution en cours. Le résultat indique sa source ; la commande n'ouvre pas, n'enregistre pas et n'exécute pas ce fichier.

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

1. Premier appel et résultat - script direct

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

Exécutez le script C# donné. Le nombre 0, là où il est passé, désigne l'index ; les parenthèses vides signifient aucun argument. Le texte Print est uniquement un exemple de message.
ScriptIndex=0 sélectionne la première exécution en cours. Le résultat indique sa source ; la commande n'ouvre pas, n'enregistre pas et n'exécute pas ce fichier.
string : chemin enregistré du fichier source ou "" s'il n'y a pas d'index. Lors de l'exécution du fichier, il s'agit généralement du chemin complet ; La commande ou la source peut ne pas avoir de fichier normal en mémoire.
Obligatoire ScriptIndex est un entier, index à partir de zéro à partir du nouveau GetScriptsList. Pour un index négatif ou manquant, le résultat vide/inconnu décrit est renvoyé. Ne passez pas le serial de la rubrique, le nom de la procédure, ni le ID du lancement depuis le IDE.

var index = 0;
var path = UO.GetScriptPath(index);
if (Truth(path!=""))
{
    UO.Print(path);
}

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

2. Utilisation dans une boucle ou une condition - fonction script

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

Il s'agit d'un exemple spécifique de partage de commandes. L'indexation des tableaux commence à zéro ; Veuillez vérifier la longueur avant manipulation. UO.Wait(250), là où il est utilisé, attend 250 millisecondes.
ScriptIndex=0 sélectionne la première exécution en cours. Le résultat indique sa source ; la commande n'ouvre pas, n'enregistre pas et n'exécute pas ce fichier.
string : chemin enregistré du fichier source ou "" s'il n'y a pas d'index. Lors de l'exécution du fichier, il s'agit généralement du chemin complet ; La commande ou la source peut ne pas avoir de fichier normal en mémoire.
Obligatoire ScriptIndex est un entier, index à partir de zéro à partir du nouveau GetScriptsList. Pour un index négatif ou manquant, le résultat vide/inconnu décrit est renvoyé. Ne passez pas le serial de la rubrique, le nom de la procédure, ni le ID du lancement depuis le IDE.

return  RunScenario();
 object? RunScenario()
{
    var indices = UO.GetScriptsList();
    foreach (var index in indices)
    {
        UO.Print(UO.GetScriptName(index) + " -> " + UO.GetScriptPath(index));
    }

    return null;
}

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

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

Sous Main se trouve la fonction entière. Ses paramètres et son résultat sont expliqués séparément de la commande API qu'il appelle.
ReadScriptPath remplace le paramètre de repli uniquement si le chemin est vide. Il s'agit d'une fonction distincte et non d'une nouvelle surcharge GetScriptPath.
string : chemin enregistré du fichier source ou "" s'il n'y a pas d'index. Lors de l'exécution du fichier, il s'agit généralement du chemin complet ; La commande ou la source peut ne pas avoir de fichier normal en mémoire.
Obligatoire ScriptIndex est un entier, index à partir de zéro à partir du nouveau GetScriptsList. Pour un index négatif ou manquant, le résultat vide/inconnu décrit est renvoyé. Ne passez pas le serial de la rubrique, le nom de la procédure, ni le ID du lancement depuis le IDE.

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(ReadScriptPath(0, "path unavailable"));
        return null;
    }

    dynamic ReadScriptPath(dynamic index, dynamic fallback)
    {
        var path = UO.GetScriptPath(index);
        if (Truth(path == ""))
        {
            return fallback;
        }

        return path;
    }

    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.GetScriptPath(scriptIndex)` — `UO.GetScriptPath(Any)`

Paramètres: scriptIndex (Any)

Résultat: string / String.

Pendant un appel:

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

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

case "getscriptpath": return new InjectionValue(bridge.GetScriptPath(Arg(0)));

UO.GetScriptState

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

Signatures C#

int UO.GetScriptState(object? scriptIndex);

Lit l'état d'exécution par index.

Paramètres

scriptIndex - Obligatoire ScriptIndex - entier, index à partir de zéro à partir du nouveau GetScriptsList. Pour un index négatif ou manquant, le résultat vide/inconnu décrit est renvoyé. Ne passez pas le serial du sujet, le nom de la procédure, ou le ID du lancement depuis le IDE.

Valeur de retour

int - code d'état : 0 = non/inconnu, 1 = en cours d'exécution, 2 = pause. Ce n'est pas bool : comparez explicitement avec 1 ou 2.

Comportement

Les lancements en cours et en pause sont pris en compte ; ceux complétés et ayant reçu une demande d’annulation sont exclus. Un script en cours d'exécution prend généralement en compte lui-même. Le simple chargement de l'onglet IDE n'est pas considéré comme un lancement.
Les index sont les positions actuelles dans l'ordre de démarrage. Le démarrage/arrêt des scripts peut changer de position. Différents appels ne forment pas un instantané atomique commun ; relisez la liste avant la prochaine commande de contrôle.
GetScriptsList donne les indices, GetScriptsCount la quantité, GetScriptState le code à trois états. Ne remplacez pas l'un par l'autre et ne traitez pas tout résultat non nul comme la valeur de true.
La pause manuelle/de débogage et la pause d'arrêt configurée sont prises en compte. L'état 1 ne garantit pas que le script consomme actuellement du processeur ou reçoit des données du serveur.

Scripts C# autonomes

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

Exemple simple

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

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

1. Premier appel et résultat - script direct

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

Exécutez le script C# donné. Le nombre 0, là où il est passé, désigne l'index ; les parenthèses vides signifient aucun argument. Le texte Print est uniquement un exemple de message.
La pause manuelle/de débogage et la pause d'arrêt configurée sont prises en compte. L'état 1 ne garantit pas que le script consomme actuellement du processeur ou reçoit des données du serveur.
int - code d'état : 0 = non/inconnu, 1 = en cours d'exécution, 2 = pause. Ce n'est pas bool : comparez explicitement avec 1 ou 2.
Obligatoire ScriptIndex est un entier, index à partir de zéro à partir du nouveau GetScriptsList. Pour un index négatif ou manquant, le résultat vide/inconnu décrit est renvoyé. Ne passez pas le serial de la rubrique, le nom de la procédure, ni le ID du lancement depuis le IDE.

int state = UO.GetScriptState(0);
string text = state switch
{
    1 => "running",
    2 => "paused",
    _ => "unknown"
};
UO.Print(text);

2. Utilisation dans une boucle ou une condition - fonction script

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

Il s'agit d'un exemple spécifique de partage de commandes. L'indexation des tableaux commence à zéro ; Veuillez vérifier la longueur avant manipulation. UO.Wait(250), là où il est utilisé, attend 250 millisecondes.
La pause manuelle/de débogage et la pause d'arrêt configurée sont prises en compte. L'état 1 ne garantit pas que le script consomme actuellement du processeur ou reçoit des données du serveur.
int - code d'état : 0 = non/inconnu, 1 = en cours d'exécution, 2 = pause. Ce n'est pas bool : comparez explicitement avec 1 ou 2.
Obligatoire ScriptIndex est un entier, index à partir de zéro à partir du nouveau GetScriptsList. Pour un index négatif ou manquant, le résultat vide/inconnu décrit est renvoyé. Ne passez pas le serial de la rubrique, le nom de la procédure, ni le ID du lancement depuis le IDE.

return  RunScenario();
 object? RunScenario()
{
    var paused = 0;
    var indices = UO.GetScriptsList();
    foreach (var index in indices)
    {
        if (Truth(UO.GetScriptState(index) == 2))
        {
            paused += 1;
        }
    }

    UO.Print(Convert.ToString(paused));
    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 :

Sous Main se trouve la fonction entière. Ses paramètres et son résultat sont expliqués séparément de la commande API qu'il appelle.
IsScriptActive convertit 1 et 2 en true et 0 en false. GetScriptState lui-même renvoie toujours un code d'état numérique.
int - code d'état : 0 = non/inconnu, 1 = en cours d'exécution, 2 = pause. Ce n'est pas bool : comparez explicitement avec 1 ou 2.
Obligatoire ScriptIndex est un entier, index à partir de zéro à partir du nouveau GetScriptsList. Pour un index négatif ou manquant, le résultat vide/inconnu décrit est renvoyé. Ne passez pas le serial de la rubrique, le nom de la procédure, ni le ID du lancement depuis le IDE.

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

     public object? RunScenario()
    {
        if (Truth(Truth(IsScriptActive(0)) == true))
        {
            UO.Print("running or paused");
        }
        else
        {
            UO.Print("not active");
        }

        return null;
    }

    dynamic IsScriptActive(dynamic index)
    {
        var state = UO.GetScriptState(index);
        return Truth(state == 1) || Truth(state == 2);
    }

    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.GetScriptState(scriptIndex)` — `UO.GetScriptState(Any)`

Paramètres: scriptIndex (Any)

Résultat: int / Integer.

Pendant un appel:

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

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

case "getscriptstate": return new InjectionValue(bridge.GetScriptState(Arg(0)));

UO.GetScriptsCount

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

Signatures C#

int UO.GetScriptsCount();

Compte les exécutions actives dans ce client.

Paramètres

Il n'y a pas de paramètres.

Valeur de retour

int >= 0 : nombre d'exécutions actives, y compris celles en pause. Il s'agit d'une quantité, pas de bool ou d'un index de script.

Comportement

Les lancements en cours et en pause sont pris en compte ; ceux complétés et ayant reçu une demande d’annulation sont exclus. Un script en cours d'exécution prend généralement en compte lui-même. Le simple chargement de l'onglet IDE n'est pas considéré comme un lancement.
Les index sont les positions actuelles dans l'ordre de démarrage. Le démarrage/arrêt des scripts peut changer de position. Différents appels ne forment pas un instantané atomique commun ; relisez la liste avant la prochaine commande de contrôle.
GetScriptsList donne les indices, GetScriptsCount la quantité, GetScriptState le code à trois états. Ne remplacez pas l'un par l'autre et ne traitez pas tout résultat non nul comme la valeur de true.
Il n'y a pas d'arguments. Le comptage ne trie pas la liste et ne modifie pas l'état des exécutions.

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

1. Premier appel et résultat - script direct

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

Exécutez le script C# donné. Le nombre 0, là où il est passé, désigne l'index ; les parenthèses vides signifient aucun argument. Le texte Print est uniquement un exemple de message.
Il n'y a pas d'arguments. Le comptage ne trie pas la liste et ne modifie pas l'état des exécutions.
int >= 0 : nombre d'exécutions actives, y compris celles en pause. Il s'agit d'une quantité, pas de bool ou d'un index de script.

var count = UO.GetScriptsCount();
UO.Print(Convert.ToString(count));

2. Utilisation dans une boucle ou une condition - fonction script

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

Il s'agit d'un exemple spécifique de partage de commandes. L'indexation des tableaux commence à zéro ; Veuillez vérifier la longueur avant manipulation. UO.Wait(250), là où il est utilisé, attend 250 millisecondes.
Il n'y a pas d'arguments. Le comptage ne trie pas la liste et ne modifie pas l'état des exécutions.
int >= 0 : nombre d'exécutions actives, y compris celles en pause. Il s'agit d'une quantité, pas de bool ou d'un index de script.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var before = UO.GetScriptsCount();
    await Delay(250);
    var after = UO.GetScriptsCount();
    UO.Print(Convert.ToString(after - before));
    return null;
}

Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));

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

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

Sous Main se trouve la fonction entière. Ses paramètres et son résultat sont expliqués séparément de la commande API qu'il appelle.
HasOtherScripts compare le décompte avec 1 : le script appelant occupe généralement une entrée. Contrairement à GetScriptsCount, la fonction d'assistance renvoie true/false.
int >= 0 : nombre d'exécutions actives, y compris celles en pause. Il s'agit d'une quantité, pas de bool ou d'un index de script.

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(HasOtherScripts()))
        {
            UO.Print("Other executions are active");
        }
        else
        {
            UO.Print("No other active executions");
        }

        return null;
    }

    dynamic HasOtherScripts()
    {
        var count = UO.GetScriptsCount();
        return count > 1;
    }

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

Paramètres: Aucun paramètre.

Résultat: int / Integer.

Pendant un appel:

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

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

case "getscriptscount": return new InjectionValue(bridge.GetScriptsCount());

UO.GetScriptsList

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

Signatures C#

dynamic UO.GetScriptsList();

Renvoie les index de script numériques actuels.

Paramètres

Il n'y a pas de paramètres.

Valeur de retour

Tableau d'int : indices 0..N-1 ou un tableau vide. Les éléments sont des nombres, pas des noms ou des entrées de texte.

Comportement

Les lancements en cours et en pause sont pris en compte ; ceux complétés et ayant reçu une demande d’annulation sont exclus. Un script en cours d'exécution prend généralement en compte lui-même. Le simple chargement de l'onglet IDE n'est pas considéré comme un lancement.
Les index sont les positions actuelles dans l'ordre de démarrage. Le démarrage/arrêt des scripts peut changer de position. Différents appels ne forment pas un instantané atomique commun ; relisez la liste avant la prochaine commande de contrôle.
GetScriptsList donne les indices, GetScriptsCount la quantité, GetScriptState le code à trois états. Ne remplacez pas l'un par l'autre et ne traitez pas tout résultat non nul comme la valeur de true.
Il n'y a pas d'arguments. Passez chaque numéro au getter correspondant du nom, du chemin ou de l'état. Le tableau résultant est un instantané distinct ; le changer ne contrôle pas les scripts.

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

1. Premier appel et résultat - script direct

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

Exécutez le script C# donné. Le nombre 0, là où il est passé, désigne l'index ; les parenthèses vides signifient aucun argument. Le texte Print est uniquement un exemple de message.
Il n'y a pas d'arguments. Passez chaque numéro au getter correspondant du nom, du chemin ou de l'état. Le tableau résultant est un instantané distinct ; le changer ne contrôle pas les scripts.
Tableau d'int : indices 0..N-1 ou un tableau vide. Les éléments sont des nombres, pas des noms ou des entrées de texte.

var indices = UO.GetScriptsList();
foreach (var index in indices)
{
    UO.Print(Convert.ToString(index) + ": " + UO.GetScriptName(index));
}

2. Utilisation dans une boucle ou une condition - fonction script

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

Il s'agit d'un exemple spécifique de partage de commandes. L'indexation des tableaux commence à zéro ; Veuillez vérifier la longueur avant manipulation. UO.Wait(250), là où il est utilisé, attend 250 millisecondes.
Il n'y a pas d'arguments. Passez chaque numéro au getter correspondant du nom, du chemin ou de l'état. Le tableau résultant est un instantané distinct ; le changer ne contrôle pas les scripts.
Tableau d'int : indices 0..N-1 ou un tableau vide. Les éléments sont des nombres, pas des noms ou des entrées de texte.

return  RunScenario();
 object? RunScenario()
{
    var indices = UO.GetScriptsList();
    if (Truth(ArrayLength(indices) > 0))
    {
        var firstIndex = indices[0];
        UO.Print(UO.GetScriptPath(firstIndex));
    }

    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. Fonction d'assistance complète - Classe de script

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

Sous Main se trouve la fonction entière. Ses paramètres et son résultat sont expliqués séparément de la commande API qu'il appelle.
FindNamedScript parcourt les index actuels et renvoie la première correspondance exacte du nom d'affichage ou -1. Les noms peuvent être répétés, les index peuvent être déplacés ultérieurement.
Tableau d'int : indices 0..N-1 ou un tableau vide. Les éléments sont des nombres, pas des noms ou des entrées de texte.

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 index = FindNamedScript("Mining");
        if (Truth(index >= 0))
        {
            UO.Print(Convert.ToString(index));
        }
        else
        {
            UO.Print("Name not found");
        }

        return null;
    }

    dynamic FindNamedScript(dynamic wanted)
    {
        var indices = UO.GetScriptsList();
        foreach (var index in indices)
        {
            if (Truth(UO.GetScriptName(index) == wanted))
            {
                return index;
            }
        }

        return -1;
    }

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

Paramètres: Aucun paramètre.

Résultat: dynamic / Array.

Pendant un appel:

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

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

case "getscriptslist": return new InjectionValue(bridge.GetScriptsList().Select(value => new InjectionValue(value)).ToArray());

UO.Launch

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

Signatures C#

int UO.Launch(object? file);
int UO.Launch(object? file, object? parameters);
int UO.Launch(object? file, object? parameters, object? workingDirectory);
int UO.Launch(object? file, object? parameters, object? workingDirectory, object? hidden);

Paramètres

file — Chemin/nom obligatoire du programme ou du document ; converti en texte, les espaces extérieurs sont supprimés. Une valeur vide donne 0 et un message d'erreur. Pour sélectionner le programme exact, utilisez le chemin complet ; Il n'est pas nécessaire d'ajouter des guillemets externes au fichier lui-même.
workingDirectory — Dossier de travail facultatif du processus. S'il y a une omission ou une ligne vide, le dossier du script en cours est pris. Si le runtime ne dispose pas d'un tel dossier, Bridge utilise le dossier de travail actuel du client. Il ne s'agit pas toujours du dossier du jeu ou du dossier client EXE.
hidden — Valeur booléenne facultative, par défaut false. true désactive l'ouverture via le shell du système d'exploitation et demande le lancement sans fenêtre de console ; vous avez besoin d'un fichier exécutable. false permet les associations de documents. Le programme GUI lui-même peut toujours afficher sa fenêtre.

Valeur de retour

int : 1 (true) si Process.Start a renvoyé un objet processus ; sinon 0 (false). Dans C# vérifiez result == 1 ou result != 0; int ne peut pas être directement comparé à true. Il ne s'agit pas d'un PID, d'un code de sortie ou d'une confirmation de l'achèvement des travaux. Si une exception se produit, une erreur est générée et 0 est renvoyé. Lors de l'ouverture d'un document via un programme déjà en cours d'exécution, le système d'exploitation ne renvoie parfois pas de nouveau processus : 0 dans ce cas ne prouve pas que le document n'a pas été ouvert.

Comportement

Seules les surcharges de un à quatre arguments sont autorisées, dans l'ordre spécifié. Pour spécifier masqué et conserver le dossier de travail par défaut, transmettez une chaîne vide comme troisième argument. Les conversions de fichier/paramètres/workingDirectory en texte ne vérifient pas l'existence du fichier à l'avance.
Le dossier par défaut est déterminé par le script en cours d'exécution. Avec Hidden=true, le chemin relatif du programme est d'abord vérifié par rapport à workingDirectory. La recherche partielle du nom du système d'exploitation et les associations sont spécifiques au système ; le chemin complet élimine toute ambiguïté. Si le dossier ou le programme de travail n'est pas disponible, le démarrage peut échouer.
Le processus externe s'exécute de manière indépendante. Launch n'attend pas qu'il se termine, ne lit pas stdout/stderr et ne le termine pas lorsque le script est arrêté. true pour caché est une demande de méthode de lancement, et non une garantie de l'invisibilité des fenêtres. L'objet Process est libéré après la demande ; le programme en cours lui-même continue de s'exécuter.

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

1. Ouvrir un rapport d'exploration de données prêt à l'emploi - script direct

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

Placez le loot-report.txt existant à côté du script. Le système d'exploitation l'ouvre avec l'application attribuée au .txt. Main renvoie le résultat de la requête Launch, pas le contenu du rapport ni la confirmation qu'il a été lu.

var started = UO.Launch("loot-report.txt");
return started;

2. Passer le chemin avec des espaces à l'éditeur - fonction de script

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

Le dossier et le rapport doivent exister ; remplacez-les par les vôtres. Chr(34) entoure le chemin complet du rapport entre guillemets doubles à l'intérieur des arguments. notepad.exe doit être accessible au système. false active la fenêtre normale de l'éditeur.

return  RunScenario();
 object? RunScenario()
{
    var report = "C:\\UO Scripts\\loot report.txt";
    var arguments = Chr(34) + report + Chr(34);
    return UO.Launch("notepad.exe", arguments, "C:\\UO Scripts", false);
    return null;
}

string Chr(object? value) => ((char)Convert.ToInt32(value)).ToString();

3. Préparez une liste de journaux locaux sans fenêtre de console - classe de script

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

L'exemple Windows exécute le cmd.exe intégré. Dans le dossier de script, log-files.txt avec une liste de *.logs est créé ou écrasé. Un troisième argument vide enregistre le dossier de script, true masque la console. true depuis Main signifie uniquement lancement : le fichier n'est peut-être pas encore prêt, et l'absence de *.log ou d'erreur d'utilitaire ne change pas le résultat Launch déjà obtenu.

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 started = UO.Launch("cmd.exe", "/d /c dir /b *.log > log-files.txt", "", true);
        if (Truth(started == 0))
        {
            return false;
        }

        return true;
        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.Launch(file)` — `UO.Launch(Any)`

Paramètres: file (Any)

Résultat: int / Integer.

Pendant un appel:

InjectionScript.Runtime.InjectionApiUO.Register [Launch].
InjectionScript.Runtime.InjectionApiUO.CompactLaunch: CompactLaunch(values).

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

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

values => new InjectionValue(CompactLaunch(values))

`UO.Launch(file, parameters)` — `UO.Launch(Any,Any)`

Paramètres: file (Any), parameters (Any)

Résultat: int / Integer.

Pendant un appel:

InjectionScript.Runtime.InjectionApiUO.Register [Launch].
InjectionScript.Runtime.InjectionApiUO.CompactLaunch: CompactLaunch(values).

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

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

values => new InjectionValue(CompactLaunch(values))

`UO.Launch(file, parameters, workingDirectory)` — `UO.Launch(Any,Any,Any)`

Paramètres: file (Any), parameters (Any), workingDirectory (Any)

Résultat: int / Integer.

Pendant un appel:

InjectionScript.Runtime.InjectionApiUO.Register [Launch].
InjectionScript.Runtime.InjectionApiUO.CompactLaunch: CompactLaunch(values).

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

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

values => new InjectionValue(CompactLaunch(values))

`UO.Launch(file, parameters, workingDirectory, hidden)` — `UO.Launch(Any,Any,Any,Any)`

Paramètres: file (Any), parameters (Any), workingDirectory (Any), hidden (Any)

Résultat: int / Integer.

Pendant un appel:

InjectionScript.Runtime.InjectionApiUO.Register [Launch].
InjectionScript.Runtime.InjectionApiUO.CompactLaunch: CompactLaunch(values).

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

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

values => new InjectionValue(CompactLaunch(values))

UO.PauseResumeScript

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

Signatures C#

void UO.PauseResumeScript(object? scriptIndex);

Active/désactive la pause manuelle d'une exécution active. Utilisez-le pour arrêter temporairement l'exploitation minière ou une autre procédure sans perdre sa progression actuelle.

Paramètres

scriptIndex - Obligatoire ScriptIndex - index de lancement actuel : 0 signifie le premier, puis 1, 2... Faites-le passer par GetScriptsList ; ce n'est pas serial, le nom du fichier, ni le résultat de StartScript. Un index négatif/manquant ne change rien.

Valeur de retour

void - aucune valeur de retour. Ne comparez pas l'appel à true/1. Vérifiez l'état en lisant séparément GetScriptState ; le résultat d'une telle lecture est 0 (pas de démarrage), 1 (en cours d'exécution), 2 (pause).

Comportement

Fonctionne uniquement avec les exécutions de la session en cours. Un onglet ouvert sans exécution n'est pas un lancement actif. L'arrêt ne supprime pas le fichier d'origine et ne déconnecte pas la connexion au serveur.
Les indices sont dynamiques : les positions peuvent changer après la fin d'une autre exécution. Plusieurs appels API ne sont pas une opération atomique. Les exemples sont conçus pour l'absence de modifications parallèles dans la liste ; recherchez à nouveau le lancement souhaité avant l'action et ne stockez pas l'index via UO.Wait.
Il s'agit d'un commutateur et non d'une commande « toujours continuer ». Les pauses manuelles et automatiques sont indépendantes : le passage en manuel ne supprime pas la pause de rupture de connexion. Le code 2 n'explique pas la raison de la pause. Si vous arrêtez votre propre lancement de cette manière, il ne pourra pas passer le prochain appel pour le continuer ; reprendre depuis IDE/manager ou un autre script.

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.

for (int index = 0; index < UO.GetScriptsCount(); index++)
    if (UO.GetScriptName(index) == "Worker")
    { UO.PauseResumeScript(index); break; }

1. Basculer la pause par nom - script direct

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

MineOre est un exemple du nom d'affichage d'une procédure déjà en cours d'exécution. FindNamedRun renvoie le premier index correspondant ou -1. Appel depuis un autre contrôleur ; appeler à nouveau modifie la pause manuelle.
Les indices sont dynamiques : les positions peuvent changer après la fin d'une autre exécution. Plusieurs appels API ne sont pas une opération atomique. Les exemples sont conçus pour l'absence de modifications parallèles dans la liste ; recherchez à nouveau le lancement souhaité avant l'action et ne stockez pas l'index via UO.Wait.

var index = FindNamedRun("MineOre");
if (Truth(index >= 0))
{
    UO.PauseResumeScript(index);
}

dynamic FindNamedRun(dynamic wanted)
{
    var indices = UO.GetScriptsList();
    foreach (var index in indices)
    {
        if (Truth(UO.GetScriptName(index) == wanted))
        {
            return index;
        }
    }
    return -1;
}

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

2. Suspendre un démarrage en cours - fonction de script

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

Check == 1 limite l'action à un déclencheur en cours d'exécution. La valeur 2 n'est pas utilisée comme indication de « pause manuelle claire » car elle peut indiquer une absence de communication.
Les indices sont dynamiques : les positions peuvent changer après la fin d'une autre exécution. Plusieurs appels API ne sont pas une opération atomique. Les exemples sont conçus pour l'absence de modifications parallèles dans la liste ; recherchez à nouveau le lancement souhaité avant l'action et ne stockez pas l'index via UO.Wait.

return  RunScenario();
 object? RunScenario()
{
    var index = FindNamedRun("MineOre");
    if (Truth(index >= 0))
    {
        if (Truth(UO.GetScriptState(index) == 1))
        {
            UO.PauseResumeScript(index);
        }
    }

    return null;
}

dynamic FindNamedRun(dynamic wanted)
{
    var indices = UO.GetScriptsList();
    foreach (var index in indices)
    {
        if (Truth(UO.GetScriptName(index) == wanted))
        {
            return index;
        }
    }

    return -1;
}

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

3. Sélectionnez exécuter par fichier - classe de script

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

Remplacez le chemin absolu par le vôtre. FindFileRun compare les chemins sans tenir compte de la casse et renvoie la première exécution de ce fichier ; Plusieurs procédures peuvent être exécutées dans un seul fichier.
Les indices sont dynamiques : les positions peuvent changer après la fin d'une autre exécution. Plusieurs appels API ne sont pas une opération atomique. Les exemples sont conçus pour l'absence de modifications parallèles dans la liste ; recherchez à nouveau le lancement souhaité avant l'action et ne stockez pas l'index via UO.Wait.

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 wantedPath = "D:/Game/AutoLoad/Scripts/Worker.csx";
        var index = FindFileRun(wantedPath);
        if (Truth(index >= 0))
        {
            UO.PauseResumeScript(index);
        }

        return null;
    }

    dynamic FindFileRun(dynamic wantedPath)
    {
        var indices = UO.GetScriptsList();
        foreach (var index in indices)
        {
            if (Truth(Convert.ToString(ReplaceText(UO.GetScriptPath(index), Chr(92), "/")) == Convert.ToString(ReplaceText(wantedPath, Chr(92), "/"))))
            {
                return index;
            }
        }

        return -1;
    }

    string Chr(object? value) => ((char)Convert.ToInt32(value)).ToString();
    bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
    string ReplaceText(object? value, object? oldValue, object? newValue) => (Convert.ToString(value) ?? "").Replace(Convert.ToString(oldValue) ?? "", Convert.ToString(newValue) ?? "");
}

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.PauseResumeScript(scriptIndex)` — `UO.PauseResumeScript(Any)`

Paramètres: scriptIndex (Any)

Résultat: void / Unit.

Pendant un appel:

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

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

case "pauseresumescript": bridge.PauseResumeScript(Arg(0)); return InjectionValue.Unit;

UO.SetEvent

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

Signatures C#

void UO.SetEvent(object? name, object? stateValue);
void UO.SetEvent(object? name, object? stateValue, object? repeatOrHandler);
void UO.SetEvent(object? nameValue, object? stateValue, object? repeatValue, object? subNameValue);

Active ou désactive la surveillance des changements dans l'état du personnage et vous permet de sélectionner une réaction unique ou répétitive. Par exemple, vous pouvez annuler la cible restante une fois après la mort ou recevoir des avertissements concernant une faible endurance. Le gestionnaire est spécifié séparément de la condition ; le script principal doit continuer à exécuter UO.Wait.

Paramètres

name — Une chaîne avec l'un des cinq noms suivants : ChangeHitPoints, ChangeMana, ChangeStamina, Death, SeeNewPlayer. Le cas n’est pas important ; le préfixe ev est acceptable, par exemple evChangeMana. Les espaces autour des bords sont supprimés. Il n'existe pas de catalogue numérique des événements ; un nom arbitraire ne crée pas de nouvel événement.
nameValue — Même nom d'événement que name ; il s'agit du nom du premier paramètre sous une forme à quatre arguments, et non d'une valeur facultative.
stateValue - true/1 active la surveillance, false/0 se désabonne. Transmettez les valeurs booléennes sans guillemets. Dans une conversion numérique, tout entier non nul inclut une observation. La désactivation n'attend ni n'arrête un gestionnaire déjà en cours d'exécution.
repeatOrHandler — Le troisième argument a deux objectifs. Une chaîne non numérique non vide, telle que "OnManaChanged", spécifie un gestionnaire de répétition automatique. Nombre/bool définit la répétition uniquement : false/0 — une opération, true/1 — répétition ; aucun gestionnaire n'est affecté dans ce formulaire. La chaîne "1" est également numérique et n'est pas un nom de procédure. Pour un gestionnaire unique, utilisez quatre arguments.
repeatValue - Sous la forme à quatre arguments : false/0 - supprimer l'abonnement après la première transition détectée, true/1 - le laisser pour les prochaines modifications. Un abonnement unique est également annulé lorsque le gestionnaire n'est pas trouvé ou que le gestionnaire refuse son lancement ; Ne confondez pas la détection d’un événement avec la réussite d’une procédure.

Valeur de retour

void - aucune valeur. Appel sur une ligne séparée, sans résultat var = et sans comparaison avec true/1. La finalisation de l'enregistrement ne confirme pas que le gestionnaire a été trouvé, démarré ou que le serveur a effectué une action. Si le nom de la procédure n'est pas trouvé sur l'événement, l'appel n'a pas lieu.

Comportement

Deux arguments : false désactive l'événement ; true implique une observation répétée sans gestionnaire. Toute procédure portant un nom correspondant n'est pas automatiquement remplacée. Ce formulaire ne renvoie pas de résultat et ne remplace pas le test HP/Mana/Dead.
Les quatre arguments spécifient explicitement le nom de l'événement, l'activation, la répétition et le gestionnaire. Les deux paramètres booléens sont écrits sans guillemets. false/0 = one-shot : la souscription est désabonnée après la première transition détectée, et non après la fin du gestionnaire.
Le réenregistrement d'un événement remplace ses paramètres précédents et mémorise l'état actuel comme nouveau point de référence. Les abonnements SetEvent et SetEventProc à un nom normalisé dans un script utilisent un seul enregistrement et ne s'accumulent pas.
ChangeHitPoints compare le HP self actuel avec l'instantané précédent ; se déclenche à la fois lors de la perte et du rétablissement de la santé. ChangeMana et ChangeStamina réagissent de la même manière dans les deux sens. Il ne s'agit pas seulement de dégâts, de consommation de mana ou de fatigue.
La mort est déclenchée lors de la transition vivant → mort. L'enregistrement d'un personnage déjà mort n'appelle pas immédiatement le gestionnaire ; mourir à nouveau après la résurrection peut le déclencher à nouveau.
SeeNewPlayer compare l'ensemble des mobiles téléchargés hors 0 et self. Le nom ne signifie pas tester le joueur réel : cela inclut NPC et les créatures. Un ou plusieurs nouveaux serial par vérification provoquent une tentative de démarrage. Le retour du mobile disparu de l'ensemble chargé peut également être considéré comme une nouvelle apparition. ID n'est pas transmis au gestionnaire - les objets nécessaires doivent être trouvés séparément.
UO.Wait et WaitAsync divisent l'attente en intervalles allant jusqu'à 25 ms et vérifient les événements après chacun ; UO.Wait(0) effectue également le contrôle. Il s'agit d'interroger l'état disponible plutôt que d'intercepter chaque paquet réseau : des changements et des retours rapides entre les vérifications peuvent être manqués. Il n'y a pas de surveillance constante dans un cycle de calcul sans UO.Wait ou après la fin du script principal.
Le nom du gestionnaire est pré-associé au délégué C# via RegisterRoutine. Le rappel est exécuté de manière asynchrone dans cette session ; une tâche ne se superpose pas à elle-même. Après la fin du scénario principal, ses autres actions sont interdites.
Un abonnement fait référence à une instance d'un script en cours d'exécution. Supprimez-le dans Main, qui l'a créé : la commande du même nom dans un gestionnaire lancé séparément modifiera ses propres abonnements. La désinscription n’arrête pas un gestionnaire déjà en cours d’exécution. Utilisez try/finally pour une sortie normale ou une erreur gérable ; forcer l'arrêt arrête également l'interrogation ultérieure de ce script.
Un nom d'événement inconnu et non vide est rejeté avec un message système lors de l'enregistrement. Un nom vide ne fait rien. La présence d'un gestionnaire est vérifiée uniquement lorsqu'elle est déclenchée ; Il est préférable de détecter à l'avance une erreur dans son nom via SubExists et de vérifier le script dans IDE.

Dans C# le gestionnaire doit être explicitement enregistré : RegisterRoutine("Handler", Handler). Les modifications apportées à HP, au mana et à l'endurance passent par la file d'attente des événements natifs ; La mort et SeeNewPlayer sont comparés à des instantanés du monde local. Les abonnements directs avec arguments sont disponibles via SubscribeEvent("UO.JournalEntry", handler) et des noms natifs similaires. Tous les abonnements sont libérés lorsque cette exécution est terminée ou annulée.

Fichiers C# téléchargés

En plus des délégués locaux, le gestionnaire actuel prend en charge les entrées C# explicitement chargées avec une clé comme Child.csx::Main. SubExists et FunRunning acceptent une telle clé ; CallSub exécute le fichier sans Args, et Exec("exec Child.csx::Main 'north gate' 42") passe Args. La clé avec des espaces est entourée de guillemets à l'intérieur de Exec. Un nom court unique est acceptable, un nom ambigu ne sélectionne pas un fichier au hasard. L'inscription locale est prioritaire. Un lancement de fichier a son propre contexte et sa propre durée de vie dans le monde/gestionnaire actuel ; les délégués locaux appartiennent à l'exécution qui les a inscrits.

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.

RegisterRoutine("HealthChanged", () => UO.Print("HP changed"));
UO.SetEvent("ChangeHitPoints", true, false, "HealthChanged");
await WaitAsync(5000);

1. Annuler une cible incomplète une fois après la mort - script direct

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

L'observation dure huit secondes. La mort d'un personnage déjà mort n'appelle pas immédiatement le gestionnaire. Le deuxième événement de décès après la résurrection n'est plus traité dans cet exemple.
Le gestionnaire vérifie le curseur actif de la cible au moment de l'exécution et appelle ensuite CancelTarget. Une file d'attente préparée sans curseur actif n'est pas annulée dans cet exemple. Le script ne ressuscite pas le personnage, n'arrête pas tous les scripts et ne termine pas Main. N'exécutez pas l'exemple si vous souhaitez garder la cible active.

var registrationOnFirstDeath = RegisterRoutine("OnFirstDeath", OnFirstDeath);
UO.SetEvent("Death", true, false, "OnFirstDeath");
try
{
    UO.Wait(8000);
}
finally
{
    UO.SetEvent("Death", false);
}

void OnFirstDeath()
{
    if (Truth(UO.Targeting()))
    {
        UO.CancelTarget();
        UO.Print("Death detected: active targeting cancelled");
    }
    else
    {
        UO.Print("Death detected: no active target");
    }
}

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

2. Avertissement d'endurance répété : forme courte - Fonction de script

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

24 × 250 ms – six secondes. 10 est notre seuil dans le gestionnaire, pas l'argument supplémentaire SetEvent. L'augmentation de l'endurance est également provoquée par le gestionnaire, mais avec une valeur de 10 le message ne s'affiche pas.
true, "OnFatigue" est différent de true, true : cette dernière option spécifie la répétition sans procédure. Le script n'augmente pas l'endurance et ne modifie pas la vitesse du serveur.

return  RunScenario();
 object? RunScenario()
{
    var registrationOnFatigue = RegisterRoutine("OnFatigue", OnFatigue);
    UO.SetEvent("evChangeStamina", true, "OnFatigue");
    try
    {
        for (int tick = (int)(1); tick <= 24; tick += (int)(1))
        {
            UO.Wait(250);
        }
    }
    finally
    {
        UO.SetEvent("ChangeStamina", false);
    }

    return null;
}

void OnFatigue()
{
    var staminaNow = UO.Stamina();
    if (Truth(staminaNow < 10))
    {
        UO.Print("Stamina is " + Convert.ToString(staminaNow) + ": consider resting");
    }
}

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

3. Basculer le gestionnaire de mana sans accumuler d'abonnements - classe de script

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

Pendant les deux premières secondes, chaque changement détecté déclenche OnManaLog. Pendant les trois secondes suivantes, OnLowMana est utilisé. L’enregistrement d’un deuxième gestionnaire ne le déclenche pas en soi.
Le remplacement n’interrompt pas l’ancienne procédure déjà en cours. Ces gestionnaires courts n’utilisent pas les variables locales principales. Si l'imposition de procédures est interdite, le manager peut refuser le lancement - pour ce mode, vérifiez Mana directement dans Main.

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 registrationOnManaLog = RegisterRoutine("OnManaLog", OnManaLog);
        var registrationOnLowMana = RegisterRoutine("OnLowMana", OnLowMana);
        UO.SetEvent("ChangeMana", true, true, "OnManaLog");
        try
        {
            UO.Wait(2000);
            UO.SetEvent("ChangeMana", true, true, "OnLowMana");
            UO.Wait(3000);
        }
        finally
        {
            UO.SetEvent("ChangeMana", false);
        }

        return null;
    }

    void OnManaLog()
    {
        UO.Print("Mana now: " + Convert.ToString(UO.Mana()));
    }

    void OnLowMana()
    {
        if (Truth(UO.Mana() < 20))
        {
            UO.Print("Mana below 20: check the cost before casting");
        }
    }

    bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
    private IDisposable RegisterRoutine(string name, Action handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Action<string[]> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<string[], Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
}

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.SetEvent(name, stateValue)` — `UO.SetEvent(Any,Any)`

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

Résultat: void / Unit.

Pendant un appel:

ClassicUO.CSharp.CSharpCallbacks.TryInvoke.
InjectionScript.Runtime.InjectionApiUO.SetEvent.
InjectionScript.Runtime.InjectionApiUO.SetEvent: SetEvent(name, stateValue, InjectionValue.True, new InjectionValue(string.Empty)).

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

case "SetEvent": SetStateEvent(arguments); return true;

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

public void SetEvent(InjectionValue name, InjectionValue stateValue)

            => SetEvent(name, stateValue, InjectionValue.True, new InjectionValue(string.Empty));

`UO.SetEvent(name, stateValue, repeatOrHandler)` — `UO.SetEvent(Any,Any,Any)`

Paramètres: name (Any), stateValue (Any), repeatOrHandler (Any)

Résultat: void / Unit.

Pendant un appel:

ClassicUO.CSharp.CSharpCallbacks.TryInvoke.
InjectionScript.Runtime.InjectionApiUO.SetEvent.
InjectionScript.Runtime.InjectionValue.ToString: repeatOrHandler.ToString().
InjectionScript.Runtime.NumberConversions.TryStr2Int: NumberConversions.TryStr2Int(raw, out _).
InjectionScript.Runtime.InjectionApiUO.SetEvent: SetEvent(name, stateValue, InjectionValue.True, repeatOrHandler).

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

case "SetEvent": SetStateEvent(arguments); return true;

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

public void SetEvent(InjectionValue name, InjectionValue stateValue, InjectionValue repeatOrHandler)

        {

            string raw = repeatOrHandler.ToString() ?? string.Empty;

            if (!string.IsNullOrWhiteSpace(raw) && !NumberConversions.TryStr2Int(raw, out _))

                SetEvent(name, stateValue, InjectionValue.True, repeatOrHandler);

            else

                SetEvent(name, stateValue, repeatOrHandler, new InjectionValue(string.Empty));

        }

`UO.SetEvent(nameValue, stateValue, repeatValue, subNameValue)` — `UO.SetEvent(Any,Any,Any,Any)`

Paramètres: nameValue (Any), stateValue (Any), repeatValue (Any), subNameValue (Any)

Résultat: void / Unit.

Pendant un appel:

ClassicUO.CSharp.CSharpCallbacks.TryInvoke.
InjectionScript.Runtime.InjectionApiUO.SetEvent.
InjectionScript.Runtime.InjectionApiUO.NormalizeLegacyEventName: NormalizeLegacyEventName(nameValue.ToString()).
InjectionScript.Runtime.InjectionValue.ToString: nameValue.ToString().
InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(stateValue).
InjectionScript.Runtime.InjectionApiUO.IsSupportedLegacyEventName: IsSupportedLegacyEventName(name).
InjectionScript.Runtime.InjectionApiUO.SystemMessage: SystemMessage($"SetEvent: unsupported event '{name}'. Supported: SeeNewPlayer, Death, ChangeHitPoints, ChangeMana, ChangeStamina.").
InjectionScript.Runtime.InjectionApiUO.NormalizeLegacyEventHandler: NormalizeLegacyEventHandler(subNameValue.ToString()).
InjectionScript.Runtime.InjectionApiUO.CaptureLegacyEventSnapshot: CaptureLegacyEventSnapshot(subscription).

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

case "SetEvent": SetStateEvent(arguments); return true;

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

public void SetEvent(InjectionValue nameValue, InjectionValue stateValue, InjectionValue repeatValue, InjectionValue subNameValue)

        {

            string name = NormalizeLegacyEventName(nameValue.ToString());

            if (string.IsNullOrEmpty(name))

                return;



            bool enabled = NumberConversions.ToInt(stateValue) != 0;

            eventStates[name] = enabled ? 1 : 0;

            if (!enabled)

            {

                legacyEvents.Remove(name);

                return;

            }



            if (!IsSupportedLegacyEventName(name))

            {

                eventStates[name] = 0;

                legacyEvents.Remove(name);

                SystemMessage($"SetEvent: unsupported event '{name}'. Supported: SeeNewPlayer, Death, ChangeHitPoints, ChangeMana, ChangeStamina.");

                return;

            }



            var subscription = new LegacyEventSubscription

            {

                Name = name,

                Repeat = NumberConversions.ToInt(repeatValue) != 0,

                Handler = NormalizeLegacyEventHandler(subNameValue.ToString())

            };

            CaptureLegacyEventSnapshot(subscription);

            legacyEvents[name] = subscription;

        }

UO.SetEventProc

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

Signatures C#

void UO.SetEventProc(object? eventname, object? procname);

Désigne une procédure que le client exécutera lorsqu'un état observé change : par exemple, lorsque la santé est perdue, que le mana change ou qu'un nouveau mobile apparaît. Permet de séparer la réaction du cycle principal. L'enregistrement lui-même n'exécute rien : le script principal doit rester actif ; Les points de contrôle C#, WaitAsync et UO.Wait gèrent les événements.

Paramètres

eventname — Une chaîne avec l'un des cinq noms suivants : ChangeHitPoints, ChangeMana, ChangeStamina, Death, SeeNewPlayer. Le cas n’est pas important ; le préfixe ev est acceptable, par exemple evChangeMana. Les espaces autour des bords sont supprimés. Il n'existe pas de catalogue numérique des événements ; un nom arbitraire ne crée pas de nouvel événement.

Valeur de retour

void - aucune valeur. Appel sur une ligne séparée, sans résultat var = et sans comparaison avec true/1. La finalisation de l'enregistrement ne confirme pas que le gestionnaire a été trouvé, démarré ou que le serveur a effectué une action. Si le nom de la procédure n'est pas trouvé sur l'événement, l'appel n'a pas lieu.

Comportement

Les deux arguments sont requis. L'abonnement est récurrent : les nouvelles modifications détectées provoquent de nouvelles tentatives de lancement. Dans un script en cours d'exécution, un gestionnaire est affecté à un nom d'événement normalisé ; la réinscription le remplace et met à jour l’instantané initial. SetEventProc(event, "") se désabonne dans le même script. Pour une réaction unique, utilisez SetEvent(event, true, false, "Handler").
ChangeHitPoints compare le HP self actuel avec l'instantané précédent ; se déclenche à la fois lors de la perte et du rétablissement de la santé. ChangeMana et ChangeStamina réagissent de la même manière dans les deux sens. Il ne s'agit pas seulement de dégâts, de consommation de mana ou de fatigue.
La mort est déclenchée lors de la transition vivant → mort. L'enregistrement d'un personnage déjà mort n'appelle pas immédiatement le gestionnaire ; mourir à nouveau après la résurrection peut le déclencher à nouveau.
SeeNewPlayer compare l'ensemble des mobiles téléchargés hors 0 et self. Le nom ne signifie pas tester le joueur réel : cela inclut NPC et les créatures. Un ou plusieurs nouveaux serial par vérification provoquent une tentative de démarrage. Le retour du mobile disparu de l'ensemble chargé peut également être considéré comme une nouvelle apparition. ID n'est pas transmis au gestionnaire - les objets nécessaires doivent être trouvés séparément.
UO.Wait et WaitAsync divisent l'attente en intervalles allant jusqu'à 25 ms et vérifient les événements après chacun ; UO.Wait(0) effectue également le contrôle. Il s'agit d'interroger l'état disponible plutôt que d'intercepter chaque paquet réseau : des changements et des retours rapides entre les vérifications peuvent être manqués. Il n'y a pas de surveillance constante dans un cycle de calcul sans UO.Wait ou après la fin du script principal.
Le nom du gestionnaire est pré-associé au délégué C# via RegisterRoutine. Le rappel est exécuté de manière asynchrone dans cette session ; une tâche ne se superpose pas à elle-même. Après la fin du scénario principal, ses autres actions sont interdites.
Un abonnement fait référence à une instance d'un script en cours d'exécution. Supprimez-le dans Main, qui l'a créé : la commande du même nom dans un gestionnaire lancé séparément modifiera ses propres abonnements. La désinscription n’arrête pas un gestionnaire déjà en cours d’exécution. Utilisez try/finally pour une sortie normale ou une erreur gérable ; forcer l'arrêt arrête également l'interrogation ultérieure de ce script.
Un nom d'événement inconnu et non vide est rejeté avec un message système lors de l'enregistrement. Un nom vide ne fait rien. La présence d'un gestionnaire est vérifiée uniquement lorsqu'elle est déclenchée ; Il est préférable de détecter à l'avance une erreur dans son nom via SubExists et de vérifier le script dans IDE.

Dans C# le gestionnaire doit être explicitement enregistré : RegisterRoutine("Handler", Handler). Les modifications apportées à HP, au mana et à l'endurance passent par la file d'attente des événements natifs ; La mort et SeeNewPlayer sont comparés à des instantanés du monde local. Les abonnements directs avec arguments sont disponibles via SubscribeEvent("UO.JournalEntry", handler) et des noms natifs similaires. Tous les abonnements sont libérés lorsque cette exécution est terminée ou annulée.

Fichiers C# téléchargés

En plus des délégués locaux, le gestionnaire actuel prend en charge les entrées C# explicitement chargées avec une clé comme Child.csx::Main. SubExists et FunRunning acceptent une telle clé ; CallSub exécute le fichier sans Args, et Exec("exec Child.csx::Main 'north gate' 42") passe Args. La clé avec des espaces est entourée de guillemets à l'intérieur de Exec. Un nom court unique est acceptable, un nom ambigu ne sélectionne pas un fichier au hasard. L'inscription locale est prioritaire. Un lancement de fichier a son propre contexte et sa propre durée de vie dans le monde/gestionnaire actuel ; les délégués locaux appartiennent à l'exécution qui les a inscrits.

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.

RegisterRoutine("HealthChanged", () => UO.Print("HP changed"));
UO.SetEventProc("ChangeHitPoints", "HealthChanged");
await WaitAsync(5000);

1. Surveiller les changements de santé pendant 10 secondes - script direct

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

ChangeHitPoints observe HP de son personnage. OnHealthChanged - nom de la méthode ci-dessous/au-dessus de Main dans le même fichier chargé. UO.Wait gère les événements ; un deuxième argument vide désactive la répétition.
Le gestionnaire avertit uniquement et ne sélectionne pas automatiquement le traitement. Lors du changement de HP 60 → 50 → 70 deux réactions sont effectuées ; Ce n'est pas un compteur d'accès.

var registrationOnHealthChanged = RegisterRoutine("OnHealthChanged", OnHealthChanged);
UO.SetEventProc("ChangeHitPoints", "OnHealthChanged");
try
{
    for (int tick = (int)(1); tick <= 40; tick += (int)(1))
    {
        UO.Wait(250);
    }
}
finally
{
    UO.SetEventProc("ChangeHitPoints", "");
}

void OnHealthChanged()
{
    var hp = UO.HP();
    if (Truth(hp < 40))
    {
        UO.Print("Low health: " + Convert.ToString(hp) + ". Check healing or retreat.");
    }
    else
    {
        UO.Print("Health changed: " + Convert.ToString(hp));
    }
}

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

2. La surveillance du mana et de l'endurance pendant la préparation est une fonction de script

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

evChangeMana et ChangeMana sont un seul événement. Il existe deux abonnements indépendants et deux gestionnaires différents, et non deux gestionnaires portant le même nom. Les seuils 20 et 10 peuvent être modifiés.
L'attente dure 5 secondes. La récupération des ressources est également détectée, mais n'émet pas d'avertissement lorsque la valeur est déjà supérieure au seuil.

return  RunScenario();
 object? RunScenario()
{
    var registrationOnManaChanged = RegisterRoutine("OnManaChanged", OnManaChanged);
    var registrationOnStaminaChanged = RegisterRoutine("OnStaminaChanged", OnStaminaChanged);
    UO.SetEventProc("evChangeMana", "OnManaChanged");
    UO.SetEventProc("ChangeStamina", "OnStaminaChanged");
    try
    {
        for (int tick = (int)(1); tick <= 20; tick += (int)(1))
        {
            UO.Wait(250);
        }
    }
    finally
    {
        UO.SetEventProc("ChangeMana", "");
        UO.SetEventProc("ChangeStamina", "");
    }

    return null;
}

void OnManaChanged()
{
    if (Truth(UO.Mana() < 20))
    {
        UO.Print("Mana below 20: postpone expensive spells");
    }
}

void OnStaminaChanged()
{
    if (Truth(UO.Stamina() < 10))
    {
        UO.Print("Stamina below 10: consider a movement break");
    }
}

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

3. Remarquez les nouveaux mobiles, puis désactivez la surveillance - classe de script

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

SeeNewPlayer détecte l'occurrence de serial dans l'ensemble de mobiles chargé, y compris NPC. Charger cinq créatures à la fois ne garantit pas cinq invocations.
GetMobiles() - lecture séparée de l'ensemble réel, et non ID de l'événement. Pour sélectionner un ennemi, des conditions explicites sont nécessaires ; l’exemple n’attaque intentionnellement personne.

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 registrationOnMobileAppeared = RegisterRoutine("OnMobileAppeared", OnMobileAppeared);
        UO.SetEventProc("SeeNewPlayer", "OnMobileAppeared");
        try
        {
            UO.Wait(5000);
        }
        finally
        {
            UO.SetEventProc("SeeNewPlayer", "");
        }

        UO.Wait(1000);
        return null;
    }

    void OnMobileAppeared()
    {
        var mobiles = UO.GetMobiles();
        UO.Print("Loaded mobiles now: " + Convert.ToString(ArrayLength(mobiles)));
    }

    int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
    private IDisposable RegisterRoutine(string name, Action handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Action<string[]> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<string[], Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
}

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.SetEventProc(eventname, procname)` — `UO.SetEventProc(Any,Any)`

Paramètres: eventname (Any), procname (Any)

Résultat: void / Unit.

Pendant un appel:

ClassicUO.CSharp.CSharpCallbacks.TryInvoke.
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Text: Text(1).
InjectionScript.Runtime.InjectionApiUO.SetEvent: SetEvent(arguments[0], InjectionValue.False).
InjectionScript.Runtime.InjectionApiUO.SetEvent: SetEvent(arguments[0], InjectionValue.True, InjectionValue.True, arguments[1]).

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

case "SetEventProc":
                SetStateEvent([arguments[0], !string.IsNullOrWhiteSpace(Convert.ToString(arguments[1])), true, arguments[1]]);
                return true;

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

case "seteventproc":

                {

                    if (string.IsNullOrWhiteSpace(Text(1)))

                        SetEvent(arguments[0], InjectionValue.False);

                    else

                        SetEvent(arguments[0], InjectionValue.True, InjectionValue.True, arguments[1]);

                    return InjectionValue.Unit;

                }

UO.SetPauseScriptOnDisconnectStatus

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

Signatures C#

void UO.SetPauseScriptOnDisconnectStatus(object? value);

Modifie la règle selon laquelle les scripts doivent s'arrêter lorsque la connexion est perdue.

Paramètres

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

Valeur de retour

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

Comportement

SetPauseScriptOnDisconnectStatus définit _manager.PauseScriptsOnDisconnect = activé != 0. Les scripts déjà en cours d'exécution ne reçoivent pas la commande PauseResumeScript ici.
Modifie le paramètre client. La valeur n'est pas le résultat d'un test de connexion et ne confirme pas le traitement 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.SetPauseScriptOnDisconnectStatus");
UO.SetPauseScriptOnDisconnectStatus(1);

1. Appel direct - script direct

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

Modifie la règle selon laquelle les scripts doivent s'arrêter lorsque la connexion est perdue.

UO.SetPauseScriptOnDisconnectStatus(1);

2. Option explicite - fonction de script

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

SetPauseScriptOnDisconnectStatus définit _manager.PauseScriptsOnDisconnect = activé != 0. Les scripts déjà en cours d'exécution ne reçoivent pas la commande PauseResumeScript ici.

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

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

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

Modifie le paramètre client. La valeur n'est pas le résultat d'un test de connexion et ne confirme pas le traitement par le serveur.

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

     public object? RunScenario()
    {
        ApplyMode(1);
        return null;
    }

    void ApplyMode(dynamic mode)
    {
        UO.SetPauseScriptOnDisconnectStatus(mode);
    }
}

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

Paramètres: value (Any)

Résultat: void / Unit.

Pendant un appel:

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

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

case "setpausescriptondisconnectstatus": bridge.SetPauseScriptOnDisconnectStatus(Arg(0)); return InjectionValue.Unit;

UO.SetScriptName

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

Signatures C#

void UO.SetScriptName(object? scriptIndex, object? value);

Modifie le nom d'affichage d'une exécution active. Aide à faire la distinction entre les tâches en cours d'exécution dans la liste et via GetScriptName.

Paramètres

scriptIndex - Obligatoire ScriptIndex - index de lancement actuel : 0 signifie le premier, puis 1, 2... Faites-le passer par GetScriptsList ; ce n'est pas serial, le nom du fichier, ni le résultat de StartScript. Un index négatif/manquant ne change rien.
value - Valeur requise - nouveau nom, converti en chaîne. Les espaces sont autorisés ; une chaîne vide est également acceptable. Il s'agit de la signature de l'exécution en cours et non du nouveau nom du fichier ou de la procédure dans la source.

Valeur de retour

void - aucune valeur de retour. Ne comparez pas l'appel à true/1. Vérifiez l'état en lisant séparément GetScriptState ; le résultat d'une telle lecture est 0 (pas de démarrage), 1 (en cours d'exécution), 2 (pause).

Comportement

Fonctionne uniquement avec les exécutions de la session en cours. Un onglet ouvert sans exécution n'est pas un lancement actif. L'arrêt ne supprime pas le fichier d'origine et ne déconnecte pas la connexion au serveur.
Les indices sont dynamiques : les positions peuvent changer après la fin d'une autre exécution. Plusieurs appels API ne sont pas une opération atomique. Les exemples sont conçus pour l'absence de modifications parallèles dans la liste ; recherchez à nouveau le lancement souhaité avant l'action et ne stockez pas l'index via UO.Wait.

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.

for (int index = 0; index < UO.GetScriptsCount(); index++)
    if (UO.GetScriptName(index) == "Worker")
    { UO.SetScriptName(index, "Worker renamed"); break; }

1. Donnez un nom clair à la tâche - script direct

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

MineOre est recherché dans les exécutions actives, Mining est la nouvelle signature. Les noms entre guillemets sont créés par l’utilisateur et peuvent être remplacés.
Les indices sont dynamiques : les positions peuvent changer après la fin d'une autre exécution. Plusieurs appels API ne sont pas une opération atomique. Les exemples sont conçus pour l'absence de modifications parallèles dans la liste ; recherchez à nouveau le lancement souhaité avant l'action et ne stockez pas l'index via UO.Wait.

var index = FindNamedRun("MineOre");
if (Truth(index >= 0))
{
    UO.SetScriptName(index, "Mining");
}

dynamic FindNamedRun(dynamic wanted)
{
    var indices = UO.GetScriptsList();
    foreach (var index in indices)
    {
        if (Truth(UO.GetScriptName(index) == wanted))
        {
            return index;
        }
    }
    return -1;
}

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

2. Distinguer les tâches de différents fichiers - fonction de script

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

Remplacez wantedPath par votre chemin absolu. La signature du premier lancement actif de ce fichier change, mais le fichier sur le disque reste au même endroit.
Les indices sont dynamiques : les positions peuvent changer après la fin d'une autre exécution. Plusieurs appels API ne sont pas une opération atomique. Les exemples sont conçus pour l'absence de modifications parallèles dans la liste ; recherchez à nouveau le lancement souhaité avant l'action et ne stockez pas l'index via UO.Wait.

return  RunScenario();
 object? RunScenario()
{
    var wantedPath = "D:/Game/AutoLoad/Scripts/Worker.csx";
    var index = FindFileRun(wantedPath);
    if (Truth(index >= 0))
    {
        UO.SetScriptName(index, "Worker A");
    }

    return null;
}

dynamic FindFileRun(dynamic wantedPath)
{
    var indices = UO.GetScriptsList();
    foreach (var index in indices)
    {
        if (Truth(Convert.ToString(ReplaceText(UO.GetScriptPath(index), Chr(92), "/")) == Convert.ToString(ReplaceText(wantedPath, Chr(92), "/"))))
        {
            return index;
        }
    }

    return -1;
}

string Chr(object? value) => ((char)Convert.ToInt32(value)).ToString();
bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
string ReplaceText(object? value, object? oldValue, object? newValue) => (Convert.ToString(value) ?? "").Replace(Convert.ToString(oldValue) ?? "", Convert.ToString(newValue) ?? "");

3. Ajouter un état à la signature - Classe de script

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

GetScriptState = 2 ajoute le texte en pause au nom. Il s'agit d'une signature unique : elle n'est pas automatiquement mise à jour après la poursuite et ne contrôle pas la pause elle-même.
Les indices sont dynamiques : les positions peuvent changer après la fin d'une autre exécution. Plusieurs appels API ne sont pas une opération atomique. Les exemples sont conçus pour l'absence de modifications parallèles dans la liste ; recherchez à nouveau le lancement souhaité avant l'action et ne stockez pas l'index via UO.Wait.

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 index = FindNamedRun("Mining");
        if (Truth(index >= 0))
        {
            var newName = "Mining";
            if (Truth(UO.GetScriptState(index) == 2))
            {
                newName = "Mining (paused)";
            }

            UO.SetScriptName(index, newName);
        }

        return null;
    }

    dynamic FindNamedRun(dynamic wanted)
    {
        var indices = UO.GetScriptsList();
        foreach (var index in indices)
        {
            if (Truth(UO.GetScriptName(index) == wanted))
            {
                return index;
            }
        }

        return -1;
    }

    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.SetScriptName(scriptIndex, value)` — `UO.SetScriptName(Any,Any)`

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

Résultat: void / Unit.

Pendant un appel:

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

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

case "setscriptname": bridge.SetScriptName(Arg(0), Text(1)); return InjectionValue.Unit;

UO.StartScript

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

Signatures C#

int UO.StartScript(object? scriptPath);

Paramètres

Valeur de retour

int : nombre de runs actifs après un run accepté ; 65535 (0xFFFF) = erreur de démarrage. Ce n'est pas l'index du nouveau script, ni bool, ni le résultat de l'achèvement.

Comportement

Les lancements en cours et en pause sont pris en compte ; ceux complétés et ayant reçu une demande d’annulation sont exclus. Un script en cours d'exécution prend généralement en compte lui-même. Le simple chargement de l'onglet IDE n'est pas considéré comme un lancement.
Les index sont les positions actuelles dans l'ordre de démarrage. Le démarrage/arrêt des scripts peut changer de position. Différents appels ne forment pas un instantané atomique commun ; relisez la liste avant la prochaine commande de contrôle.
GetScriptsList donne les indices, GetScriptsCount la quantité, GetScriptState le code à trois états. Ne remplacez pas l'un par l'autre et ne traitez pas tout résultat non nul comme la valeur de true.

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.StartScript("Scripts/Worker.csx");
UO.Print("StartScript: " + Convert.ToString(result));

1. Premier appel et résultat - script direct

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

Exécutez le script C# donné. Le nombre 0, là où il est passé, désigne l'index ; les parenthèses vides signifient aucun argument. Le texte Print est uniquement un exemple de message.
Avant les exemples, créez séparément les fichiers Worker.csx spécifiés. Un chemin invalide/inaccessible, un Main inapproprié, un C# désactivé ou une exécution parallèle désactivée entraînera un échec. Si l'exécution précédente est toujours arrêtée, une nouvelle tentative différée est possible ; accepter le début ne signifie pas l’achèvement. Un court script peut se terminer avant de lire la quantité retournée.
int : nombre de runs actifs après un run accepté ; 65535 (0xFFFF) = erreur de démarrage. Ce n'est pas l'index du nouveau script, ni bool, ni le résultat de l'achèvement.
Obligatoire ScriptPath est une chaîne. Le chemin relatif commence dans le dossier AutoLoad de ce client ; le chemin absolu est acceptable. Entourez les chemins avec des espaces entre guillemets. Vous avez besoin de .csx avec un code de niveau supérieur ou d'un .cs/.csproj régulier avec un point d'entrée pris en charge C#.

var count = UO.StartScript("Scripts/Worker.csx");
if (Truth(count==65535))
{
    UO.Print("launch failed");
}
else
{
    UO.Print("Active executions: " + Convert.ToString(count));
}

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

2. Utilisation dans une boucle ou une condition - fonction script

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

Il s'agit d'un exemple spécifique de partage de commandes. L'indexation des tableaux commence à zéro ; Veuillez vérifier la longueur avant manipulation. UO.Wait(250), là où il est utilisé, attend 250 millisecondes.
Avant les exemples, créez séparément les fichiers Worker.csx spécifiés. Un chemin invalide/inaccessible, un Main inapproprié, un C# désactivé ou une exécution parallèle désactivée entraînera un échec. Si l'exécution précédente est toujours arrêtée, une nouvelle tentative différée est possible ; accepter le début ne signifie pas l’achèvement. Un court script peut se terminer avant de lire la quantité retournée.
int : nombre de runs actifs après un run accepté ; 65535 (0xFFFF) = erreur de démarrage. Ce n'est pas l'index du nouveau script, ni bool, ni le résultat de l'achèvement.
Obligatoire ScriptPath est une chaîne. Le chemin relatif commence dans le dossier AutoLoad de ce client ; le chemin absolu est acceptable. Entourez les chemins avec des espaces entre guillemets. Vous avez besoin de .csx avec un code de niveau supérieur ou d'un .cs/.csproj régulier avec un point d'entrée pris en charge C#.

return  RunScenario();
 object? RunScenario()
{
    var count = UO.StartScript("Scripts/My Worker.csx");
    if (Truth(count != 65535))
    {
        var indices = UO.GetScriptsList();
        foreach (var index in indices)
        {
            UO.Print(Convert.ToString(index) + ": " + UO.GetScriptPath(index));
        }
    }

    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 :

Sous Main se trouve la fonction entière. Ses paramètres et son résultat sont expliqués séparément de la commande API qu'il appelle.
TryStartCSharp compare le résultat avec 65535 et renvoie true/false. Il n'attend pas l'achèvement et ne transforme pas la quantité en indice.
int : nombre de runs actifs après un run accepté ; 65535 (0xFFFF) = erreur de démarrage. Ce n'est pas l'index du nouveau script, ni bool, ni le résultat de l'achèvement.
Obligatoire ScriptPath est une chaîne. Le chemin relatif commence dans le dossier AutoLoad de ce client ; le chemin absolu est acceptable. Entourez les chemins avec des espaces entre guillemets. Vous avez besoin de .csx avec un code de niveau supérieur ou d'un .cs/.csproj régulier avec un point d'entrée pris en charge C#.

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(TryStartCSharp("Scripts/Worker.csx")))
        {
            UO.Print("launch accepted");
        }
        else
        {
            UO.Print("check file, Main and execution settings");
        }

        return null;
    }

    dynamic TryStartCSharp(dynamic fileName)
    {
        var count = UO.StartScript(fileName);
        return Truth(count != 65535);
    }

    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.StartScript(scriptPath)` — `UO.StartScript(Any)`

Paramètres: scriptPath (Any)

Résultat: int / Integer.

Pendant un appel:

InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.StartScript: bridge.StartScript(Text(0)).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Text: Text(0).

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

case "startscript": return new InjectionValue(bridge.StartScript(Text(0)));

UO.StopAllScripts

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

Signatures C#

void UO.StopAllScripts();

Paramètres

Il n'y a pas de paramètres.

Valeur de retour

void - aucune valeur de retour. Ne comparez pas l'appel à true/1. Vérifiez l'état en lisant séparément GetScriptState ; le résultat d'une telle lecture est 0 (pas de démarrage), 1 (en cours d'exécution), 2 (pause).

Comportement

Fonctionne uniquement avec les exécutions de la session en cours. Un onglet ouvert sans exécution n'est pas un lancement actif. L'arrêt ne supprime pas le fichier d'origine et ne déconnecte pas la connexion au serveur.
Les indices sont dynamiques : les positions peuvent changer après la fin d'une autre exécution. Plusieurs appels API ne sont pas une opération atomique. Les exemples sont conçus pour l'absence de modifications parallèles dans la liste ; recherchez à nouveau le lancement souhaité avant l'action et ne stockez pas l'index via UO.Wait.
Il n'y a pas d'arguments. Les procédures en cours d'exécution et suspendues, les requêtes en attente et la file d'attente de réexécution sont annulées. Le script appelant obtient également une annulation : ne mettez pas la sauvegarde/le rapport requis après cette commande. Les autres profils et processus ne sont pas affecté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.StopAllScripts");
UO.StopAllScripts();

1. Arrêt général inconditionnel - script direct

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

La commande a des parenthèses vides. Effectuez la sauvegarde souhaitée avant d'appeler. Le contrôleur lui-même sera également arrêté.
Les indices sont dynamiques : les positions peuvent changer après la fin d'une autre exécution. Plusieurs appels API ne sont pas une opération atomique. Les exemples sont conçus pour l'absence de modifications parallèles dans la liste ; recherchez à nouveau le lancement souhaité avant l'action et ne stockez pas l'index via UO.Wait.

UO.StopAllScripts();

2. Arrêtez-vous à la mort du personnage - fonction de script

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

Connected vérifie l'entrée dans le monde, Dead vérifie la mort. StopAllScripts n'est appelé que lorsque les deux conditions sont remplies ; l'exemple les vérifie une fois.
Les indices sont dynamiques : les positions peuvent changer après la fin d'une autre exécution. Plusieurs appels API ne sont pas une opération atomique. Les exemples sont conçus pour l'absence de modifications parallèles dans la liste ; recherchez à nouveau le lancement souhaité avant l'action et ne stockez pas l'index via UO.Wait.

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

    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. Arrêt général après cinq secondes - classe de script

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

5000 correspond aux millisecondes dans UO.Wait, pas au paramètre StopAllScripts. Une pause manuelle ou automatique du contrôleur peut retarder l'exécution ; Ce n'est pas une minuterie indépendante.
Les indices sont dynamiques : les positions peuvent changer après la fin d'une autre exécution. Plusieurs appels API ne sont pas une opération atomique. Les exemples sont conçus pour l'absence de modifications parallèles dans la liste ; recherchez à nouveau le lancement souhaité avant l'action et ne stockez pas l'index via UO.Wait.

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 delayMs = 5000;
        UO.Wait(delayMs);
        UO.StopAllScripts();
        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.StopAllScripts()` — `UO.StopAllScripts()`

Paramètres: Aucun paramètre.

Résultat: void / Unit.

Pendant un appel:

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

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

case "stopallscripts": bridge.StopAllScripts(); return InjectionValue.Unit;

UO.StopScript

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

Signatures C#

void UO.StopScript(object? scriptIndex);

Demande l’annulation d’un lancement actif, y compris celui en pause. À utiliser lorsque cette exécution doit être terminée plutôt que de continuer plus tard.

Paramètres

scriptIndex - Obligatoire ScriptIndex - index de lancement actuel : 0 signifie le premier, puis 1, 2... Faites-le passer par GetScriptsList ; ce n'est pas serial, le nom du fichier, ni le résultat de StartScript. Un index négatif/manquant ne change rien.

Valeur de retour

void - aucune valeur de retour. Ne comparez pas l'appel à true/1. Vérifiez l'état en lisant séparément GetScriptState ; le résultat d'une telle lecture est 0 (pas de démarrage), 1 (en cours d'exécution), 2 (pause).

Comportement

Fonctionne uniquement avec les exécutions de la session en cours. Un onglet ouvert sans exécution n'est pas un lancement actif. L'arrêt ne supprime pas le fichier d'origine et ne déconnecte pas la connexion au serveur.
Les indices sont dynamiques : les positions peuvent changer après la fin d'une autre exécution. Plusieurs appels API ne sont pas une opération atomique. Les exemples sont conçus pour l'absence de modifications parallèles dans la liste ; recherchez à nouveau le lancement souhaité avant l'action et ne stockez pas l'index via UO.Wait.
L'annulation est coopérative : attend une pause et est vérifiée par le moteur ; Les actions déjà envoyées au serveur ne sont pas annulées. Un lancement annulé est immédiatement supprimé de la liste active, même si la libération des ressources peut continuer. Ne vérifiez pas l'achèvement par rapport à l'index précédent : il se peut qu'il y ait déjà une autre exécution sous celui-ci.

Scripts C# autonomes

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

Exemple simple

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

for (int index = 0; index < UO.GetScriptsCount(); index++)
    if (UO.GetScriptName(index) == "Worker")
    { UO.StopScript(index); break; }

1. Arrêter une procédure - script direct

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

MineOre — nom de lancement. -1 n'est pas transféré vers StopScript. Après l'arrêt, l'index enregistré n'est plus utilisé.
Les indices sont dynamiques : les positions peuvent changer après la fin d'une autre exécution. Plusieurs appels API ne sont pas une opération atomique. Les exemples sont conçus pour l'absence de modifications parallèles dans la liste ; recherchez à nouveau le lancement souhaité avant l'action et ne stockez pas l'index via UO.Wait.

var index = FindNamedRun("MineOre");
if (Truth(index >= 0))
{
    UO.StopScript(index);
}

dynamic FindNamedRun(dynamic wanted)
{
    var indices = UO.GetScriptsList();
    foreach (var index in indices)
    {
        if (Truth(UO.GetScriptName(index) == wanted))
        {
            return index;
        }
    }
    return -1;
}

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

2. Arrêter un démarrage en pause - fonction de script

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

Le code 2 sélectionne une exécution en pause. StopScript le termine plutôt que de le reprendre ; d'autres tâches se poursuivent.
Les indices sont dynamiques : les positions peuvent changer après la fin d'une autre exécution. Plusieurs appels API ne sont pas une opération atomique. Les exemples sont conçus pour l'absence de modifications parallèles dans la liste ; recherchez à nouveau le lancement souhaité avant l'action et ne stockez pas l'index via UO.Wait.

return  RunScenario();
 object? RunScenario()
{
    var index = FindNamedRun("MineOre");
    if (Truth(index >= 0))
    {
        if (Truth(UO.GetScriptState(index) == 2))
        {
            UO.StopScript(index);
        }
    }

    return null;
}

dynamic FindNamedRun(dynamic wanted)
{
    var indices = UO.GetScriptsList();
    foreach (var index in indices)
    {
        if (Truth(UO.GetScriptName(index) == wanted))
        {
            return index;
        }
    }

    return -1;
}

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

3. Arrêter de s'exécuter à partir d'un fichier spécifique - classe de script

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

Le chemin absolu sélectionne la première exécution active du fichier. Il ne s'agit pas de supprimer un fichier ni d'arrêter toutes les procédures de ce fichier.
Les indices sont dynamiques : les positions peuvent changer après la fin d'une autre exécution. Plusieurs appels API ne sont pas une opération atomique. Les exemples sont conçus pour l'absence de modifications parallèles dans la liste ; recherchez à nouveau le lancement souhaité avant l'action et ne stockez pas l'index via UO.Wait.

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 wantedPath = "D:/Game/AutoLoad/Scripts/Worker.csx";
        var index = FindFileRun(wantedPath);
        if (Truth(index >= 0))
        {
            UO.StopScript(index);
        }

        return null;
    }

    dynamic FindFileRun(dynamic wantedPath)
    {
        var indices = UO.GetScriptsList();
        foreach (var index in indices)
        {
            if (Truth(Convert.ToString(ReplaceText(UO.GetScriptPath(index), Chr(92), "/")) == Convert.ToString(ReplaceText(wantedPath, Chr(92), "/"))))
            {
                return index;
            }
        }

        return -1;
    }

    string Chr(object? value) => ((char)Convert.ToInt32(value)).ToString();
    bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
    string ReplaceText(object? value, object? oldValue, object? newValue) => (Convert.ToString(value) ?? "").Replace(Convert.ToString(oldValue) ?? "", Convert.ToString(newValue) ?? "");
}

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.StopScript(scriptIndex)` — `UO.StopScript(Any)`

Paramètres: scriptIndex (Any)

Résultat: void / Unit.

Pendant un appel:

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

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

case "stopscript": bridge.StopScript(Arg(0)); return InjectionValue.Unit;

UO.SubExists

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

Signatures C#

int UO.SubExists(object? subrutineName);

Vérifie si le délégué C# avec le nom spécifié est enregistré avec l'exécution en cours. Il s'agit d'un registre de fonctions de rappel pour une session donnée, sans recherche automatique de méthodes arbitraires par réflexion ; les entrées de fichiers explicitement chargées sont également accessibles par clé.

Paramètres

subrutineName est le nom de chaîne donné par RegisterRoutine. Les espaces autour des bords sont supprimés ; Les recherches de noms enregistrés ne sont pas sensibles à la casse.

Valeur de retour

int : 1 - la condition est remplie, 0 - non remplie. Enregistrez le résultat d'un appel si plusieurs vérifications en ont besoin.

Comportement

L'inscription et les tâches appartiennent à la même exécution. Un autre personnage, profil ou exécution ultérieure possède son propre registre.
RegisterRoutine accepte Action, Func<Task> ou un délégué avec un tableau d'arguments de chaîne pour Exec. La suppression de l'enregistrement n'exécute pas le code et empêche toute recherche ultérieure du nom.
Le script principal doit rester actif tant que ses assistants sont nécessaires : une fois terminé, les tâches sont annulées et les inscriptions et abonnements sont libérés.
FunRunning n'est pas un index de gestionnaire. GetScriptsList et GetScriptState décrivent des lancements de fichiers indépendants ; le rappel local ne reçoit pas d'index séparé.
L'erreur de rappel est transmise au script principal lors de la prochaine vérification. Les boucles WaitAsync, UO.Wait et instrumentées C# prennent en charge la pause, l'annulation et le traitement de la file d'attente d'événements.

Fichiers C# téléchargés

En plus des délégués locaux, le gestionnaire actuel prend en charge les entrées C# explicitement chargées avec une clé comme Child.csx::Main. SubExists et FunRunning acceptent une telle clé ; CallSub exécute le fichier sans Args, et Exec("exec Child.csx::Main 'north gate' 42") passe Args. La clé avec des espaces est entourée de guillemets à l'intérieur de Exec. Un nom court unique est acceptable, un nom ambigu ne sélectionne pas un fichier au hasard. L'inscription locale est prioritaire. Un lancement de fichier a son propre contexte et sa propre durée de vie dans le monde/gestionnaire actuel ; les délégués locaux appartiennent à l'exécution qui les a inscrits.

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.

RegisterRoutine("Hello", () => UO.Print("Hello"));
UO.Print("Registered flag: " + UO.SubExists("Hello"));

1. Exécuter la procédure facultative disponible - script direct

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

La commande renvoie int : dans C# vérifiez le résultat != 0 ou le résultat == 1 ; une comparaison directe avec true n'est pas acceptable. La définition de WeightWatch est donnée ci-dessous et est enregistrée via RegisterRoutine avant l'appel de la commande.
Enregistrez l'exemple dans un fichier séparé, chargez-le dans IDE/manager et exécutez Main pour que le reste des procédures se retrouve dans le répertoire. WeightWatch/ManaWatch - procédures d'entraînement entièrement définies ici : trois mesures poids/mana avec un intervalle de UO.Wait(1000), c'est-à-dire 1000 ms, sorties uniquement à l'entrée dans le monde. Il ne s’agit pas d’une surveillance continue ; une pause peut prolonger le temps. Pour l'exemple avec deux tâches, le lancement simultané de procédures doit être autorisé.

var registrationWeightWatch = RegisterRoutine("WeightWatch", WeightWatch);
if (Truth(Truth(UO.SubExists("WeightWatch")) == true))
{
    UO.CallSub("WeightWatch");
}

while (UO.FunRunning("WeightWatch") != 0) await WaitAsync(25);

void WeightWatch()
{
    dynamic sample = 0;
    for (sample = (int)(1); sample <= 3; sample += (int)(1))
    {
        if (Truth(UO.Connected()))
        {
            UO.Print("Weight: " + Convert.ToString(UO.Weight()));
        }
        UO.Wait(1000);
    }
}

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

2. Sélectionnez le gestionnaire de secours - fonction de script

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

WeightWatch peut être chargé à partir d'un autre fichier. S'il n'est pas présent, le ManaWatch déclaré ici est sélectionné. Si le primaire est trouvé mais ne peut pas démarrer, il n'y aura pas de transition automatique vers le secondaire.
Enregistrez l'exemple dans un fichier séparé, chargez-le dans IDE/manager et exécutez Main pour que le reste des procédures se retrouve dans le répertoire. WeightWatch/ManaWatch - procédures d'entraînement entièrement définies ici : trois mesures poids/mana avec un intervalle de UO.Wait(1000), c'est-à-dire 1000 ms, sorties uniquement à l'entrée dans le monde. Il ne s’agit pas d’une surveillance continue ; une pause peut prolonger le temps. Pour l'exemple avec deux tâches, le lancement simultané de procédures doit être autorisé.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var registrationManaWatch = RegisterRoutine("ManaWatch", ManaWatch);
    if (Truth(UO.SubExists("WeightWatch") == 1))
    {
        UO.CallSub("WeightWatch");
    }
    else if (Truth(UO.SubExists("ManaWatch")))
    {
        UO.CallSub("ManaWatch");
    }

    while (UO.FunRunning("ManaWatch") != 0)
        await WaitAsync(25);
    return null;
}

void ManaWatch()
{
    dynamic sample = 0;
    for (sample = (int)(1); sample <= 3; sample += (int)(1))
    {
        if (Truth(UO.Connected()))
        {
            UO.Print("Mana: " + Convert.ToString(UO.Mana()));
        }

        UO.Wait(1000);
    }
}

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 deux définitions avant d'exécuter - classe de script

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

HaveMonitors teste deux noms en utilisant &&. S’il en manque au moins un, Main n’appelle aucune tâche. Un ensemble de définitions est testé, ce qui ne garantit pas une exécution simultanée réussie.
Enregistrez l'exemple dans un fichier séparé, chargez-le dans IDE/manager et exécutez Main pour que le reste des procédures se retrouve dans le répertoire. WeightWatch/ManaWatch - procédures d'entraînement entièrement définies ici : trois mesures poids/mana avec un intervalle de UO.Wait(1000), c'est-à-dire 1000 ms, sorties uniquement à l'entrée dans le monde. Il ne s’agit pas d’une surveillance continue ; une pause peut prolonger le temps. Pour l'exemple avec deux tâches, le lancement simultané de procédures doit être autorisé.

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 registrationWeightWatch = RegisterRoutine("WeightWatch", WeightWatch);
        var registrationManaWatch = RegisterRoutine("ManaWatch", ManaWatch);
        if (Truth(HaveMonitors()))
        {
            UO.CallSub("WeightWatch");
            UO.CallSub("ManaWatch");
        }

        while (UO.FunRunning("WeightWatch") != 0 || UO.FunRunning("ManaWatch") != 0)
            await WaitAsync(25);
        return null;
    }

    dynamic HaveMonitors()
    {
        return UO.SubExists("WeightWatch") != 0 && UO.SubExists("ManaWatch") != 0;
    }

    void WeightWatch()
    {
        dynamic sample = 0;
        for (sample = (int)(1); sample <= 3; sample += (int)(1))
        {
            if (Truth(UO.Connected()))
            {
                UO.Print("Weight: " + Convert.ToString(UO.Weight()));
            }

            UO.Wait(1000);
        }
    }

    void ManaWatch()
    {
        dynamic sample = 0;
        for (sample = (int)(1); sample <= 3; sample += (int)(1))
        {
            if (Truth(UO.Connected()))
            {
                UO.Print("Mana: " + Convert.ToString(UO.Mana()));
            }

            UO.Wait(1000);
        }
    }

    bool Truth(object? value) => value is bool flag ? flag : value is string text ? !string.IsNullOrEmpty(text) : value != null && Convert.ToDouble(value) != 0;
    private IDisposable RegisterRoutine(string name, Action handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Action<string[]> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
    private IDisposable RegisterRoutine(string name, Func<string[], Task> handler) => global::ClassicUO.CSharp.CSharpScriptContext.Current.RegisterRoutine(name, handler);
}

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.SubExists(subrutineName)` — `UO.SubExists(String)`

Paramètres: subrutineName (String)

Résultat: int / Integer.

Pendant un appel:

ClassicUO.CSharp.CSharpCallbacks.TryInvoke.
InjectionScript.Runtime.InjectionApiUO.SubExists.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.SubExists: bridge.SubExists(subrutineName).

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

case "SubExists":
                string requested = Convert.ToString(arguments[0]) ?? "";
                result = Exists(requested) || events is ICSharpScriptHost known && known.HasCSharpScript(requested) ? 1 : 0;
                return true;

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

public int SubExists(string subrutineName) => bridge.SubExists(subrutineName) ? 1 : 0;

UO.Terminate

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

Signatures C#

void UO.Terminate();
void UO.Terminate(object? subrutineName);

Paramètres

subrutineName — Chaîne facultative. Sans argument ou avec une chaîne vide, le dernier fichier démarré est sélectionné ; "all" demande l’annulation de toutes les exécutions. Pour les fichiers C#, utilisez une clé exacte du catalogue, par exemple harvest.csx::Main. Un nom de callback local comme Harvest nécessite un enregistrement explicite avec RegisterRoutine. Un fichier possède une entrée Main ; les méthodes de classe ne deviennent pas automatiquement des procédures exécutables séparées.

Valeur de retour

void : la commande ne renvoie pas de nombre et n'attend pas la fin du thread de travail. Elle demande immédiatement une annulation. L'exécution s'arrête au prochain contrôle d'annulation ; les pauses, les points d'arrêt et les attentes intégrées sont interrompus. Les actions du serveur déjà envoyées avant l'annulation ne sont pas annulées.

Comportement

UO.FunRunning(name) == 0 peut aussi apparaître immédiatement après une demande d’annulation. Cela ne signifie pas que le callback précédent a terminé son bloc finally. Un autre CallSub ou Exec portant le même nom local est ignoré jusqu’à la fin réelle du worker précédent.

UO.Terminate() sélectionne les procédures par ordre d'exécution plutôt que par nom, ligne d'éditeur, heure de la dernière action ou ordre d'affichage. Une procédure en pause est également considérée comme en cours d'exécution.
La cible locale appartenant à ce parcours est effacée et la route automatique restante est annulée. L'annulation du mouvement est effectuée sur le fil de jeu ; si l'itinéraire a déjà été remplacé par un autre trajet ou un autre utilisateur, l'ancien propriétaire ne l'arrête pas. Les étapes envoyées au serveur ne sont pas rappelées.
La commande reste disponible lorsque le paramètre pour un lancement simultané est activé. Une procédure annulée libère de l'espace uniquement après que son thread de travail a été effacé ; Avant cela, le nouveau lancement est ignoré.
L'arrêt par nom annule également les démarrages en attente correspondants. Les procédures terminées ne sont pas modifiées. Le client signale l'absence de lancement approprié dans le statut. Un appel bloqué vers un plugin natif tiers qui ne prend pas en charge l'annulation ne peut pas être interrompu en toute sécurité en supprimant de force le thread.

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.

Pour les fichiers C#, utilisez une clé exacte du catalogue, par exemple harvest.csx::Main. Un nom de callback local comme Harvest nécessite un enregistrement explicite avec RegisterRoutine. Un fichier possède une entrée Main ; les méthodes de classe ne deviennent pas automatiquement des procédures exécutables séparées.

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.

UO.Terminate("harvest.csx::Main");
UO.Print("Cancellation requested for harvest.csx::Main");

1. Arrêtez de récolter par votre nom, en laissant d'autres procédures - script direct

Cela demande l’annulation de harvest.csx::Main déjà en cours. Le message ne confirme ni la fin de son bloc finally ni l’annulation des actions de jeu déjà effectuées.

var procedureName = "harvest.csx::Main";
UO.Terminate(procedureName);
UO.Print("Cancellation requested for harvest.csx::Main");

2. Sélectionnez Principal uniquement à partir d'un fichier spécifique - fonction de script

La clé exacte harvest.csx::Main diffère de heal.csx::Main. Remplacez-la par la clé de votre fichier chargé. Des suffixes arbitraires comme #2 ne créent aucune autre entrée.

return  RunScenario();
 object? RunScenario()
{
    var procedureKey = "harvest.csx::Main";
    UO.Terminate(procedureKey);
    UO.Print("Cancellation requested: " + procedureKey);
    return null;
}

3. Formulaire de console compatible via Exec - classe de script

La chaîne terminate harvest.csx::Main transmet la même clé à UO.Exec. Une clé contenant des espaces doit être entre guillemets dans la chaîne de commande.

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 command = "terminate harvest.csx::Main";
        UO.Exec(command);
        UO.Print("Stop command sent");
        return null;
    }
}

4. Arrêter la dernière exécution lorsque la santé est faible - script direct

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

Le formulaire sans arguments sélectionne le dernier script en cours d'exécution, y compris celui en pause. Il s’agit d’une politique d’exemple et non d’une réponse obligatoire à une mauvaise santé ; un message s'affiche avant la demande d'annulation.

if (UO.GetHP() <= 30)
{
    UO.Print("Low health: requesting cancellation of the most recent run");
    UO.Terminate();
}

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

Paramètres: Aucun paramètre.

Résultat: void / Unit.

Pendant un appel:

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

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

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

`UO.Terminate(subrutineName)` — `UO.Terminate(String)`

Paramètres: subrutineName (String)

Résultat: void / Unit.

Pendant un appel:

ClassicUO.CSharp.CSharpCallbacks.TryInvoke.
InjectionScript.Runtime.InjectionApiUO.Terminate.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Terminate: bridge.Terminate(subrutineName).

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

case "Terminate" when arguments.Length == 1:
                string routine = Convert.ToString(arguments[0]) ?? "";
                if (Exists(routine)) { Cancel(routine); return true; }
                if (Cancel(routine)) return true;
                return false;

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

public void Terminate(string subrutineName) => bridge.Terminate(subrutineName);

UO.TerminateAll

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

Signatures C#

void UO.TerminateAll();

Paramètres

Il n'y a pas de paramètres.

Valeur de retour

void : aucun résultat. La commande demande l'annulation de toutes les exécutions en cours et rend le contrôle au code appelant s'il n'a pas lui-même été annulé. Les threads de travail sont nettoyés après le déclenchement de leurs contrôles d'annulation.

Comportement

La syntaxe exacte est UO.TerminateAll(), sans espace à l'intérieur du nom ni argument. UO.Terminate("all") est pris en charge comme notation alternative compatible.
Arrête les procédures en cours d'exécution, les procédures mises en pause et avec point d'arrêt manuellement, les attentes intégrées et les exécutions retardées enregistrées. Il est sécuritaire de rappeler lorsqu’il n’y a pas de travail.
La suppression des sites touristiques locaux et des itinéraires automatiques prend en compte leurs propriétaires. Le parcours restant du script arrêté est annulé sur le thread de jeu ; le nouvel itinéraire de l'utilisateur qui l'a remplacé est enregistré. Les packages de mouvements déjà envoyés ne sont pas annulés.
L'annulation n'annule pas les actions déjà envoyées au serveur. Le code de plug-in natif tiers sans prise en charge de l'annulation ne peut pas être détruit en toute sécurité avec le flux. Les nouveaux démarrages explicites après l'exécution de la commande sont autorisés ; lorsque la case est cochée, ils attendent que l'espace se libère dans le sens où la tentative est ignorée plutôt que mise en file d'attente jusqu'à ce que le nettoyage soit terminé.

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

1. Empêcher tous les scripts de vérifier à l'intérieur d'un script de travail - script direct

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

TerminateAll n'a aucun paramètre. La condition UO.Dead() vérifie la mort du personnage avant la prochaine itération.
Lorsque la condition est remplie, l'exécution principale en cours et les exécutions restantes C# sont annulées. Le message Print se trouve avant l'arrêt, car après lui le code de cette procédure s'arrête.
WaitAsync(250) spécifie la pause 250 millisecondes entre les vérifications dans cet exemple. La commande stop ne modifie pas la durée des pauses normales du script.

for (int cycle = (int)(1); cycle <= 10; cycle += (int)(1))
{
    if (Truth(UO.Dead()))
    {
        UO.Print("Character is dead: stopping all C# scripts");
        UO.TerminateAll();
    }
    await Delay(250);
}

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;

2. Formulaire compatible avec all - fonction script

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

Cette notation alternative utilise UO.Terminate avec un paramètre subrutineName="all". C'est l'équivalent de UO.TerminateAll().
La chaîne all est une valeur spéciale, pas le nom de la procédure qui doit être déclarée. EmergencyStop est également annulé.
Pour la touche de jeu d'urgence, utilisez la commande sur une ligne du premier exemple : la procédure séparée EmergencyStop est elle-même soumise à l'interdiction des exécutions parallèles.

return  RunScenario();
 object? RunScenario()
{
    UO.Print("Stopping all C# scripts");
    UO.Terminate("all");
    return null;
}

3. Arrêter l'opération générale si un objet requis devient indisponible - classe de script

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

GetSerial stocke serial l'objet requis, ici son propre sac à dos. Exists=0 signifie que cet objet est actuellement inconnu du client.
TerminateAll est appelé sans arguments uniquement lorsque la condition sélectionnée n'est pas respectée. Cette politique arrête toutes les procédures, pas seulement le travail sur un sac à dos donné.
Tout d'abord, le motif de l'arrêt s'affiche. Une fois la demande d'annulation effectuée, la procédure en cours prend également fin ; on ne peut pas compter sur la prochaine action.

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.GetSerial("backpack");
        if (Truth(UO.Exists(bag) == 0))
        {
            UO.Print("Required backpack is unavailable: stopping all scripts");
            UO.TerminateAll();
        }

        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. Arrêtez tout travail après avoir perdu la connexion - script direct

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

S'il n'y a pas de connexion, tous les démarrages sont arrêtés. La commande ne renvoie pas le nombre de scripts annulés et annule également l'exécution en cours.

if (UO.Connected() == 0)
{
    UO.Print("Disconnected: requesting cancellation of every active script");
    UO.TerminateAll();
}

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

Paramètres: Aucun paramètre.

Résultat: void / Unit.

Pendant un appel:

InjectionScript.Runtime.InjectionApiUO.TerminateAll.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Terminate: bridge.Terminate("all").

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

public void TerminateAll() => bridge.Terminate("all");

UO.Time

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

Signatures C#

int UO.Time();

Lit l'heure locale de l'ordinateur en utilisant le numéro HHMMSS. Pratique pour sélectionner la durée de fonctionnement autorisée, pas pour mesurer la durée.

Paramètres

Il n'y a pas de paramètres.

Valeur de retour

int HHMMSS, 0..235959 avec minutes et secondes valides. 07:29:35 -> 72935 ; minuit -> 0. Zéro est une heure valide, pas une erreur ou un indicateur logique false.

Comportement

Il n'y a pas de paramètres, pas de formulaires avec arguments. Les parenthèses vides ne lisent que l'heure : l'appel n'attend pas, ne démarre pas de chronomètre et n'envoie pas de paquets au jeu.
RealTimeSource.Lit maintenant DateTime.Maintenant : la date/heure locale de l'ordinateur, pas UTC, ni l'heure du fragment, ni l'horloge du jeu. Le fuseau horaire, l’heure d’été et le changement manuel de l’horloge affectent les résultats. Chaque appel capture un moment différent.
Les zéros non significatifs ne sont pas conservés, les millisecondes ne sont pas conservées. Numériquement, 13:00:00 moins 12:59:59 donne 4041, bien qu'une seconde se soit écoulée. A minuit, la valeur redevient nulle.
Ne soustrayez pas les codes de calendrier pour calculer le retard. Utilisez Timer() et deux marques d'une exécution. L'horloge du calendrier peut revenir en arriè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.Time();
UO.Print("Time: " + Convert.ToString(result));

1. Afficher les champs de temps individuels - script direct

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

le timbre est lu une seule fois afin de ne pas mélanger les différentes secondes. Int(stamp/10000) — heures ; Int(stamp/100) MOD 100 — minutes ; MOD 100 – secondes. Une simple chaîne ne remplit pas les champs avec des zéros.

var stamp = UO.Time();
var hour = stamp / 10000;
var minute = stamp / 100 % 100;
var second = stamp % 100;
UO.Print(Convert.ToString(hour) + ":" + Convert.ToString(minute) + ":" + Convert.ToString(second));

2. Autoriser les séries uniquement dans le créneau du soir - fonction script

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

180000 - 18:00:00 inclus ; 220000 - 22:00:00 non inclus. Une vérification décide s'il faut continuer Main. Le planning n'est pas enregistré et la série ne démarre pas automatiquement.

return  RunScenario();
 object? RunScenario()
{
    var stamp = UO.Time();
    if (Truth(stamp >= 180000) && Truth(stamp < 220000))
    {
        UO.Print("Evening batch permitted by local schedule");
    }
    else
    {
        UO.Print("Outside the local schedule");
        return null;
    }

    return null;
}

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

3. Envisager un intervalle après minuit - classe de scénario

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

ClockInWindow(stamp,first,last) accepte un HHMMSS valide. 230000..20000 signifie de 23:00 inclus à 02:00 non inclus : OR prend en compte minuit. Des limites égales signifient un intervalle vide. Pendant la période calme, Main se termine ; La fonction est donnée dans son intégralité.

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(ClockInWindow(UO.Time(), 230000, 20000)))
        {
            UO.Print("Local quiet period; do not start a new batch");
            return null;
        }

        UO.Print("Outside the local quiet period");
        return null;
    }

    dynamic ClockInWindow(dynamic stamp, dynamic first, dynamic last)
    {
        if (Truth(first == last))
        {
            return false;
        }

        if (Truth(first < last))
        {
            return Truth(stamp >= first) && Truth(stamp < last);
        }

        return Truth(stamp >= first) || Truth(stamp < last);
    }

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

Paramètres: Aucun paramètre.

Résultat: int / Integer.

Pendant un appel:

InjectionScript.Runtime.InjectionApiUO.Time.

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

public int Time()

        {

            var now = timeSource.Now;

            return now.Hour * 10000 + now.Minute * 100 + now.Second;

        }

UO.Timer

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

Signatures C#

int UO.Timer();

Lit la durée d'exécution de l'exécution actuelle en dixièmes de seconde. Convient à vos propres retards et marques d'action.

Paramètres

Il n'y a pas de paramètres.

Valeur de retour

int 0..2147483647; l'unité est 100 ms. À 399 ms 3 sera renvoyée. Il s'agit de l'indication de l'horloge, pas de true/false ni de la recharge restante.

Comportement

Il n'y a pas de paramètres, pas de formulaires avec arguments. Les parenthèses vides ne lisent que l'heure : l'appel n'attend pas, ne démarre pas de chronomètre et n'envoie pas de paquets au jeu.
L'origine appartient à cette instance d'exécution. Une nouvelle procédure en cours d'exécution peut recevoir une nouvelle horloge ; Vous ne pouvez pas comparer les valeurs de différentes exécutions ni les stocker sous forme de date absolue. Pendant UO.Wait et une pause du script, le temps réel continue de s'écouler.
La partie fractionnaire des dixièmes est écartée. Après environ 2485.5 jours, le nombre atteint 2147483647 et y reste sans déborder.
Il s'agit de votre retard, pas d'un temps de recharge du serveur pour une compétence/sort ou d'une confirmation de succès. La commande ne vous permet pas de contourner les restrictions du serveur sur les mouvements, les sorts ou les scripts.

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

1. Mesurer la durée d'une opération - script direct

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

WaitAsync(250) demande 250 ms ; le délai réel peut être plus long. La différence entre les deux marques est divisée par 10.0 pour obtenir les secondes. Étape d'indication UO.Timer - 100 ms.

var started = UO.Timer();
await Delay(250);
var elapsed = UO.Timer() - started;
var seconds = elapsed / 10.0;
UO.Print("Elapsed seconds: " + Convert.ToString(seconds));

Task Delay(object? milliseconds) => WaitAsync(checked((int)Convert.ToDouble(milliseconds)));

2. Limiter l'attente d'un réticule déjà demandé à trois secondes - fonction script

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

La limite 30 est donnée en unités de cette fonction. UO.Wait(50) libère l'exécution entre les contrôles. UO.Targeting lit la présence d'un viseur ; l'exemple ne lance ni ne cible. Si la vue n'apparaît pas, le cycle se termine.
Un contrôle supplémentaire de la limite supérieure met fin à l'attente même si le compteur s'est arrêté à la limite int. L'état de l'oscilloscope est lu à plusieurs reprises et peut changer entre les lectures.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var started = UO.Timer();
    while (Truth(UO.Timer() - started < 30) && !(Truth(UO.Targeting())))
    {
        if (Truth(UO.Timer() >= 2147483647))
        {
            break;
        }

        await Delay(50);
    }

    if (Truth(UO.Targeting()))
    {
        UO.Print("Target cursor available");
    }
    else
    {
        UO.Print("Target wait ended");
    }

    return null;
}

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

3. Fonction d'intervalle de nouvelle tentative personnalisée - Classe de script

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

IntervalPassed(démarré, courant, intervalle) est entièrement défini sous Principal. interval=5 — une demi-seconde en unités de cette horloge. L'intervalle négatif, l'inversion et int sur la borne supérieure donnent false ; atteindre l'intervalle donne exactement true.
Il s'agit de votre retard, pas d'un temps de recharge du serveur pour une compétence/sort ou d'une confirmation de succès. La commande ne vous permet pas de contourner les restrictions du serveur sur les mouvements, les sorts ou les scripts.

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

    async public Task<object?> RunScenarioAsync()
    {
        var started = UO.Timer();
        await Delay(500);
        var ready = IntervalPassed(started, UO.Timer(), 5);
        if (Truth(ready))
        {
            UO.Print("Local retry interval passed");
        }

        return null;
    }

    dynamic IntervalPassed(dynamic started, dynamic current, dynamic interval)
    {
        if (Truth(interval < 0) || Truth(current < started))
        {
            return false;
        }

        if (Truth(current >= 2147483647))
        {
            return false;
        }

        return current - started >= interval;
    }

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

Paramètres: Aucun paramètre.

Résultat: int / Integer.

Pendant un appel:

InjectionScript.Runtime.InjectionApiUO.Timer.

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

public int Timer() => (int)Math.Max(0d, Math.Min(int.MaxValue, timeSource.SinceStart.TotalMilliseconds / 100d));

UO.Wait

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

Signatures C#

void UO.Wait(object? waitTimeMS);

Met en pause le script en cours pendant le nombre de millisecondes spécifié. Utile entre les vérifications d'état répétées pour empêcher le script de s'exécuter en boucle continue.

Paramètres

waitTimeMS — Temps entier en millisecondes : 1000 = une seconde. Utilisez 0..2147483647. Il ne s'agit pas du nombre d'étapes, ni des secondes, ni du délai d'attente de confirmation du serveur.

Valeur de retour

void - aucun résultat. Appelez sur une ligne séparée. La fin du délai ne signifie pas que l'objet a bougé, que le sort est terminé ou que la connexion est établie : vérifiez séparément l'état souhaité.

Comportement

Zero ne crée aucun réel retard et ne convient pas comme pause dans une boucle rapide. Un temps négatif ne signifie pas l'infini : UO.Wait le réduit à 0 ; UO.Wait/sleep peut le rejeter avec des rappels actifs, et dans le pont client sans eux, il n'attendra pas. Pour un script portable, utilisez uniquement des heures non négatives.

Exemple .csx

UO.Wait(100);
// For an asynchronous script, use the host helper:
await WaitAsync(100);

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

1. UO.Wait - 1 - script direct

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

250 - quart de seconde. La ligne suivante est exécutée après avoir attendu ; Le message Delay complete est le texte de l’exemple, pas le résultat renvoyé.

UO.Wait(250);
UO.Print("Delay complete");

2. UO.Wait — 2 — fonction de script

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

WaitForOnline est entièrement déclaré dans ce script. L'argument 20 signifie un maximum de vingt pauses de 250 ms. La connexion est vérifiée avant les pauses et à nouveau après la dernière. L'assistant renvoie l'état Connected (1/0) ; La commande wait elle-même ne renvoie rien et ne se connecte pas au serveur.

return  RunScenario();
 object? RunScenario()
{
    return WaitForOnline(20);
    return null;
}

dynamic WaitForOnline(dynamic checks)
{
    while (Truth(checks > 0))
    {
        if (Truth(UO.Connected()))
        {
            return 1;
        }

        UO.Wait(250);
        checks = checks - 1;
    }

    return UO.Connected();
}

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

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

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

La boucle effectue exactement trois lectures de poids. Entre les lectures, il y a deux pauses de 500 ms, après la dernière il n'y a pas de pause. Un message est imprimé lors de la première lecture et lorsque le poids change. La variable précédente stocke la valeur à comparer, plutôt que d'ajuster le poids du jeu.

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 = -1;
        var checks = 0;
        while (Truth(checks < 3))
        {
            var weight = UO.Weight();
            if (Truth(weight != previous))
            {
                UO.Print("Weight: " + Convert.ToString(weight));
                previous = weight;
            }

            checks = checks + 1;
            if (Truth(checks < 3))
            {
                UO.Wait(500);
            }
        }

        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.Wait(waitTimeMS)` — `UO.Wait(Any)`

Paramètres: waitTimeMS (Any)

Résultat: void / Unit.

Pendant un appel:

ClassicUO.CSharp.CSharpScriptGlobals.WaitAsync.
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
InjectionScript.Runtime.InjectionApiUO.WaitWithEvents: WaitWithEvents(Arg(0)).
InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).

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

public async Task WaitAsync(int milliseconds)
    {
        ArgumentOutOfRangeException.ThrowIfNegative(milliseconds);
        Checkpoint();
        // Short slices allow Pause to suspend further script progress promptly.
        int remaining = milliseconds;
        while (remaining > 0)
        {
            int slice = Math.Min(remaining, 25);
            await Task.Delay(slice, Cancellation).ConfigureAwait(false);
            Checkpoint(); remaining -= slice;
        }
    }

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

case "wait": WaitWithEvents(Arg(0)); return InjectionValue.Unit;

UO.Waiting

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

Signatures C#

int UO.Waiting();

Vérifie si les réponses préparées restent dans la file d'attente cible.

Paramètres

Il n'y a pas de paramètres.

Valeur de retour

int 1 - il y a une cible différée non annulée d'un objet, d'une tuile ou une annulation de la prochaine vue ; 0 - la file d'attente est vide. Il ne s'agit pas d'avoir un curseur ouvert ; pour le curseur, utilisez TargetPresent/Targeting.

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

Comportement

La file d'attente entière du client est lue. Si plusieurs procédures s'exécutent simultanément, les réponses de chacune d'elles sont prises en compte.
Zéro signifie simplement qu’aucune réponse n’est en attente. Il ne confirme pas l'utilisation réussie d'une compétence ou d'un sort sur 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.

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

1. Préparation du chèque - script direct

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

Après WaitTargetSelf et avant la cible du serveur 1 est attendue.
CancelWaitTarget efface la file d'attente ; le test suivant donne 0.

UO.WaitTargetSelf();
UO.Print(Convert.ToString(UO.Waiting()));
UO.CancelWaitTarget();

2. Attendre sans relâche que la réponse soit dépensée - fonction de script

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

Le contrôle n'a aucun paramètre. UO.Wait=50 ms, attentes maximales de 20.
Si la réponse demeure, elle est annulée. Ajoutez une vérification du résultat de l'action du serveur séparément.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var attempts = 0;
    while (Truth(UO.Waiting()) && Truth(attempts < 20))
    {
        await Delay(50);
        attempts = attempts + 1;
    }

    if (Truth(UO.Waiting()))
    {
        UO.CancelWaitTarget();
    }

    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. Afficher la différence entre la file d'attente et la vue - classe de script

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

La première ligne montre les réponses différées, la seconde l'état de la vue.
Une file d'attente sans curseur et un curseur sans file d'attente sont possibles ; ces valeurs ne sont pas interchangeables.

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("Queued: " + Convert.ToString(UO.Waiting()));
        UO.Print("Cursor: " + Convert.ToString(UO.TargetPresent()));
        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.Waiting()` — `UO.Waiting()`

Paramètres: Aucun paramètre.

Résultat: int / Integer.

Pendant un appel:

InjectionScript.Runtime.InjectionApiUO.Waiting.
ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetWaitTargetQueue: bridge.GetWaitTargetQueue().

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

public int Waiting() => bridge.GetWaitTargetQueue().Length > 0 ? 1 : 0;

ClassicUO — Bad Newbie & C# Scripts IDE

FR UO Topic scripts runtime

Scripts et exécution

Sections

Toutes les commandes du thème

Cycle de vie des scripts

Procédures / Événements

Minuteries / Waiting

Disconnect Comportement

Exemples sur le sujet

UO.GetScriptsList

UO.TerminateAll

Référence complète des commandes

UO.CallSub

Signatures C#

Paramètres

Valeur de retour

Comportement

Fichiers C# téléchargés

Scripts C# autonomes

Exemple simple

1. Démarrez l'observateur et continuez Main - script direct

2. Ne pas redémarrer une tâche active ou suspendue - fonction script

3. Deux observateurs indépendants - Classe de scénario

Implémentation de la commande

UO.CallSub(subrutineName) — UO.CallSub(String)

UO.Date

Signatures C#

Paramètres

Valeur de retour

Comportement

Scripts C# autonomes

Exemple simple

1. Nommez la série de collecte de ressources quotidiennes - script direct

2. Terminer la série lorsque le jour local change - fonction script

3. Sélectionnez l'année, le mois et le jour - classe de script

Implémentation de la commande

UO.Date() — UO.Date()

UO.Exec

Signatures C#

Paramètres

Valeur de retour

Comportement

Fichiers C# téléchargés

Scripts C# autonomes

Exemple simple

1. Utiliser la compétence sélectionnée - script direct

2. Passer l'étiquette de chaîne à la procédure locale - fonction de script

3. Exécuter un observateur séparé - Classe de script

4. Charger le script à partir du dossier avec des espaces - script direct

Implémentation de la commande

UO.Exec(parameters) — UO.Exec(String)

UO.FunRunning

Signatures C#

Paramètres

Valeur de retour

Comportement

Fichiers C# téléchargés

Scripts C# autonomes

Exemple simple

1. Exécuter un observateur enregistré sans superposition - script direct

2. Attendez la fin et lisez le résultat du travail en arrière-plan - fonction de script

3. Annuler l'assistant asynchrone enregistré - classe de script

Implémentation de la commande

UO.FunRunning(subrutineName) — UO.FunRunning(String)

UO.GetPauseScriptOnDisconnectStatus

Signatures C#

Paramètres

Valeur de retour

Comportement

Scripts C# autonomes

Exemple simple

1. Paramètres de lecture - script direct

2. Vérifiez séparément la connexion - fonction de script

3. Enregistrer la valeur - Classe de script

Implémentation de la commande

UO.GetPauseScriptOnDisconnectStatus() — UO.GetPauseScriptOnDisconnectStatus()

UO.GetScriptName

Signatures C#

Paramètres

Valeur de retour

`UO.CallSub(subrutineName)` — `UO.CallSub(String)`

`UO.Date()` — `UO.Date()`

`UO.Exec(parameters)` — `UO.Exec(String)`

`UO.FunRunning(subrutineName)` — `UO.FunRunning(String)`

`UO.GetPauseScriptOnDisconnectStatus()` — `UO.GetPauseScriptOnDisconnectStatus()`

`UO.GetScriptName(scriptIndex)` — `UO.GetScriptName(Any)`

`UO.GetScriptPath(scriptIndex)` — `UO.GetScriptPath(Any)`

`UO.GetScriptState(scriptIndex)` — `UO.GetScriptState(Any)`

`UO.GetScriptsCount()` — `UO.GetScriptsCount()`

`UO.GetScriptsList()` — `UO.GetScriptsList()`

`UO.Launch(file)` — `UO.Launch(Any)`