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

UO.LimitMove — Reichweite der Bewegung.

Home · C# · IDE · UO API · A–Z · Beispiele · Sprachen

Charakterbewegung, Wegaufbau, Türen, Hindernisse und Schrittverzögerungen. Befehle zum Bewegen von Gegenständen befinden sich unter Gegenstände → Moving Gegenstände.

UO.Move · UO.MoveXY · UO.MoveXYZ · UO.NewMoveXY · UO.Step · UO.StepQ · UO.PMove · UO.MoveOn · UO.MoveOff · UO.MoverStop · UO.CancelMove · UO.Moving · UO.IsMoving · UO.GetRun · UO.IsRunning · UO.AlwaysRun · UO.FixWalk

UO.Dir · UO.Direction · UO.GetDir · UO.GetDirection · UO.CalcDir · UO.PredictedDirection

UO.GetPathArray · UO.GetPathArray3D · UO.AddStep · UO.AddDir

UO.OpenDoor · UO.LastStepQUsedDoor

UO.moveBetweenTwoCorners · UO.moveCheckStamina · UO.moveExitOnDisconnect · UO.moveHeuristicMult · UO.moveOpenDoor · UO.moveThroughCorner · UO.moveThroughNPC · UO.moveTurnCost

UO.PredictedX · UO.PredictedY · UO.PredictedZ

UO.GetRunMountTimer · UO.GetRunUnMountTimer · UO.GetWalkMountTimer · UO.GetWalkUnmountTimer · UO.SetRunMountTimer · UO.SetRunUnmountTimer · UO.SetWalkMountTimer · UO.SetWalkUnmountTimer

Jede Befehlskarte verfügt über mehrere unabhängige Szenarien: Direktcode, Funktionen und Klassen. Nachfolgend finden Sie ausgewählte kurze Szenarien; Einschränkungen und eine vollständige Analyse sind geplant.

Parameter, Ergebnis und alle Szenarien

var x = UO.GetX() + 3;
var y = UO.GetY();
var ok = UO.NewMoveXY(x, y, true, 0, false);
if (Truth(ok))
{
    UO.Print("Destination reached");
}
else
{
    UO.Print("Destination not reached");
}

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

Parameter, Ergebnis und alle Szenarien

var x = UO.GetX();
var y = UO.GetY();
var z = UO.GetZ();
var path = UO.GetPathArray3D(x, y, z, x + 4, y, z, UO.WorldNum(), 0, 0, false);
if (Truth(ArrayLength(path) > 0))
{
    UO.Print("Steps: " + Convert.ToString(ArrayLength(path) - 1));
}

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

1 · 2

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

void UO.AddDir(object? directions);

• directions ist eine in der Legacy-Liste gespeicherte Zeichenfolge. Die Bedeutung und das Format des Werts hängen vom kompatiblen Skript ab, das ihn verwendet.

void. Der hinzugefügte Eintrag ist keine Bestätigung der Bewegung.

• Der Wert wird zur Liste AddDir des aktuellen Laufzeitstatus hinzugefügt. Der Aufruf selbst übergibt kein Bewegungspaket, bewegt das Zeichen nicht und verfügt nicht über einen dokumentierten öffentlichen Getter zum Lesen dieser Liste.

Jedes Beispiel kann als separate Datei .csx gespeichert und in IDE ausgeführt werden. Die UO-Objekt- und Wartefunktionen stellen den Host der aktuellen Spielsitzung bereit. Ersetzen Sie Demo-serial-Namen, Koordinaten und Adressen durch Ihre eigenen.

Führe diesen Code als eigene .csx-Datei aus. Die Argumente stehen direkt im Aufruf; ersetze Beispielnamen, Serials und Adressen durch eigene Werte.

Der Befehl steht in einer eigenen Anweisung. Die Meldung davor zeigt den Beginn des Aufrufs und bestätigt keine Serveraktion.

UO.Print("Calling UO.AddDir");
UO.AddDir("E");

Parameter und Ablauf:

• Speichern Sie die Richtung als Legacy-kompatiblen Eintrag, ohne das Zeichen zu verschieben.

UO.AddDir("E");

Parameter und Ablauf:

• Übergeben Sie den Wert von der Variablen an die Legacy-Liste AddDir.

return  RunScenario();
 object? RunScenario()
{
    var directionEntry = "north-east";
    UO.AddDir(directionEntry);
    return null;
}

Parameter und Ablauf:

• Jeder Aufruf fügt dem Laufzeitstatus einen weiteren String-Eintrag hinzu.
• Auch die Hilfsprozedur sendet keinen Bewegungsbefehl.

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()
    {
        AddLegacyDirection("W");
        return null;
    }

    void AddLegacyDirection(dynamic entry)
    {
        UO.AddDir(entry);
    }
}

C# unterscheidet Groß- und Kleinschreibung. Verwenden Sie den genauen UO-Namen. Numerische Flags mit 0 vergleichen; bool nur bei Rückgabetyp bool verwenden.

Parameter: directions (Any)

Ergebnis: void / Unit.

Beim Aufruf:

• InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
• InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::LegacyList: LegacyList(name).
• InjectionScript.Runtime.InjectionValue.ToString: value.ToString().

Interner Implementierungscode; kein eigenständiges Skript.

case "adddir":

                case "addfindlist":

                case "addgate":

                case "addrecall":

                case "addstep":

                    LegacyList(name).Add(string.Join("|", arguments.Select(value => value.ToString())));

                    break;

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

void UO.AddStep(object? directions);

• directions ist der Wert, den die Laufzeit in Text umwandelt und zur Kompatibilitätsliste AddStep hinzufügt. Die Richtung selbst ist nicht interpretierbar.

void. Der Aufruf gibt keinen Wert zurück und bestätigt den Umzug nicht.

• Jeder Aufruf fügt eine Zeichenfolgendarstellung des Arguments zur Liste AddStep des aktuellen Laufzeitstatus hinzu. Dieser Legacy-Eintrag sendet keinen Bewegungsbefehl und verfügt in der aktuellen Implementierung nicht über einen öffentlichen Getter.

Jedes Beispiel kann als separate Datei .csx gespeichert und in IDE ausgeführt werden. Die UO-Objekt- und Wartefunktionen stellen den Host der aktuellen Spielsitzung bereit. Ersetzen Sie Demo-serial-Namen, Koordinaten und Adressen durch Ihre eigenen.

Führe diesen Code als eigene .csx-Datei aus. Die Argumente stehen direkt im Aufruf; ersetze Beispielnamen, Serials und Adressen durch eigene Werte.

Der Befehl steht in einer eigenen Anweisung. Die Meldung davor zeigt den Beginn des Aufrufs und bestätigt keine Serveraktion.

UO.Print("Calling UO.AddStep");
UO.AddStep(2);

Parameter und Ablauf:

• Schreiben Sie den Wert in die Legacy-Liste. Der Charakter bewegt sich nicht.

UO.AddStep(2);

Parameter und Ablauf:

• Textwert übergeben: Er wird als Datensatz gespeichert und nicht als Richtung ausgeführt.

return  RunScenario();
 object? RunScenario()
{
    var legacyValue = "east";
    UO.AddStep(legacyValue);
    return null;
}

Parameter und Ablauf:

• Jeder Aufruf fügt einen separaten Eintrag zu AddStep der aktuellen Laufzeit hinzu.

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.AddStep(1);
        UO.AddStep(2);
        return null;
    }
}

C# unterscheidet Groß- und Kleinschreibung. Verwenden Sie den genauen UO-Namen. Numerische Flags mit 0 vergleichen; bool nur bei Rückgabetyp bool verwenden.

Parameter: directions (Any)

Ergebnis: void / Unit.

Beim Aufruf:

• InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
• InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias::LegacyList: LegacyList(name).
• InjectionScript.Runtime.InjectionValue.ToString: value.ToString().

Interner Implementierungscode; kein eigenständiges Skript.

case "adddir":

                case "addfindlist":

                case "addgate":

                case "addrecall":

                case "addstep":

                    LegacyList(name).Add(string.Join("|", arguments.Select(value => value.ToString())));

                    break;

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

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

Liest oder ändert die konstante Laufeinstellung des aktuellen ClassicUO-Profils.

• enabled - 0 deaktiviert den Dauerbetrieb; Jeder Wert ungleich Null schaltet es ein.

Das Formular ohne Argumente gibt 1 zurück, wenn die Einstellung aktiviert ist, andernfalls 0. Die Argumentform gibt null zurück.

• Der Wert wird aus dem aktuellen Profil gelesen. Die Einstellung ändert sich AlwaysRun und speichert das aktuelle Profil. Ohne aktives Profil gibt der Getter 0 zurück und der Setter meldet einen Fehler im Client-Protokoll und ändert die Einstellung nicht.

Jedes Beispiel kann als separate Datei .csx gespeichert und in IDE ausgeführt werden. Die UO-Objekt- und Wartefunktionen stellen den Host der aktuellen Spielsitzung bereit. Ersetzen Sie Demo-serial-Namen, Koordinaten und Adressen durch Ihre eigenen.

Führe diesen Code als eigene .csx-Datei aus. Die Argumente stehen direkt im Aufruf; ersetze Beispielnamen, Serials und Adressen durch eigene Werte.

Das Ergebnis eines Aufrufs wird im Journal ausgegeben. Zahlen werden nicht in bool umgewandelt; bei Arrays wird die Anzahl der Elemente angezeigt.

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

Parameter und Ablauf:

• Lesen Sie die Einstellung; 1 bedeutet, dass der Dauerlauf aktiviert ist.

var isAlwaysRunning = UO.AlwaysRun();
UO.Print(Convert.ToString(isAlwaysRunning));

Parameter und Ablauf:

• Aktivieren Sie den Dauerbetrieb und speichern Sie die aktuellen Profileinstellungen.

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

Parameter und Ablauf:

• Deaktivieren Sie die ständige Ausführung nur, wenn sie derzeit aktiviert ist.

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

     public object? RunScenario()
    {
        if (Truth(UO.AlwaysRun() != 0))
        {
            UO.AlwaysRun(0);
        }

        return null;
    }

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

C# unterscheidet Groß- und Kleinschreibung. Verwenden Sie den genauen UO-Namen. Numerische Flags mit 0 vergleichen; bool nur bei Rückgabetyp bool verwenden.

Parameter: Keine Parameter.

Ergebnis: int / Integer.

Beim Aufruf:

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

Interner Implementierungscode; kein eigenständiges Skript.

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

Parameter: enabled (Integer)

Ergebnis: void / Unit.

Beim Aufruf:

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

Interner Implementierungscode; kein eigenständiges Skript.

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

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

int UO.CalcDir(object? xfrom, object? yfrom, object? xto, object? yto);

Berechnet die Richtung von einem Weltpunkt zum anderen. Der Charakter bewegt sich nicht.

• xfrom — X-Koordinate des Startpunkts.
• yfrom — Y-Koordinate des Startpunkts.
• xto – X-Koordinate des Ziels.
• yto – Y-Koordinate des Ziels.

int – Richtungscode: 0=Norden, 1=Nordosten, 2=Osten, 3=Südosten, 4=Süden, 5=Südwesten, 6=Westen, 7=Nordwesten. Passende Punkte ergeben 100. Es ist nicht bool: 0 bedeutet Norden, nicht Scheitern; 1 bedeutet Nordosten, nicht Erfolg. Übergeben Sie 100 nicht als Richtung an den Schrittbefehl.

• Nur Koordinaten berechnen: keine Stapel, kein Warten, kein Laden der Karte, keine Hindernisprüfung, kein Z, keine Weltkarte. Das Team sucht nicht nach einer passierbaren Route und übernimmt keine Garantie für das Erreichen des Ziels. Die Punkte müssen zum selben Koordinatensystem gehören; Das Vermeiden von Hindernissen kann den Weg verlängern.
• Alle vier Parameter werden benötigt. Senden Sie Weltkoordinaten int im dokumentierten Bereich 0..65535. object? in der Signatur weist auf einen Universaladapter hin, nicht auf den ID des Artikels. Diese Befehle haben keine Standardwerte, keine Koordinaten innerhalb der Truhe, kein fünftes Z und keine Überladung mit einem Objekt.
• Die ursprünglichen Koordinaten werden von den Zielkoordinaten subtrahiert und anschließend werden die Vorzeichen der Differenzen überprüft. Abnehmendes Y bedeutet Norden, zunehmendes X bedeutet Osten. Ändern sich beide Koordinaten, wird unabhängig von der Größe der Unterschiede die Diagonale gewählt. Wenn beide Differenzen Null sind – 100.

Jedes Beispiel kann als separate Datei .csx gespeichert und in IDE ausgeführt werden. Die UO-Objekt- und Wartefunktionen stellen den Host der aktuellen Spielsitzung bereit. Ersetzen Sie Demo-serial-Namen, Koordinaten und Adressen durch Ihre eigenen.

Führe diesen Code als eigene .csx-Datei aus. Die Argumente stehen direkt im Aufruf; ersetze Beispielnamen, Serials und Adressen durch eigene Werte.

Das Ergebnis eines Aufrufs wird im Journal ausgegeben. Zahlen werden nicht in bool umgewandelt; bei Arrays wird die Anzahl der Elemente angezeigt.

var result = UO.CalcDir(100, 100, 101, 100);
UO.Print("CalcDir: " + Convert.ToString(result));

Parameter und Ablauf:

• Ursprung (100,100), Ziel (101,100): X erhöht sich, Y ändert sich nicht. Hauptrückführung int 2 – Osten. Der Bewegungsbefehl wird nicht aufgerufen.
• int – Richtungscode: 0=Norden, 1=Nordosten, 2=Osten, 3=Südosten, 4=Süden, 5=Südwesten, 6=Westen, 7=Nordwesten. Passende Punkte ergeben 100. Es ist nicht bool: 0 bedeutet Norden, nicht Scheitern; 1 bedeutet Nordosten, nicht Erfolg. Übergeben Sie 100 nicht als Richtung an den Schrittbefehl.
• Die ursprünglichen Koordinaten werden von den Zielkoordinaten subtrahiert und anschließend werden die Vorzeichen der Differenzen überprüft. Abnehmendes Y bedeutet Norden, zunehmendes X bedeutet Osten. Ändern sich beide Koordinaten, wird unabhängig von der Größe der Unterschiede die Diagonale gewählt. Wenn beide Differenzen Null sind – 100.

return UO.CalcDir(100,100,101,100);

Parameter und Ablauf:

• Beide Punkte sind gleich (100,100). Direction=100 bedeutet eine Übereinstimmung, daher gibt Main string „already there“ zurück. An verschiedenen Stellen funktioniert eine andere Verzweigung. Es wird 100 überprüft, nicht true.
• int – Richtungscode: 0=Norden, 1=Nordosten, 2=Osten, 3=Südosten, 4=Süden, 5=Südwesten, 6=Westen, 7=Nordwesten. Passende Punkte ergeben 100. Es ist nicht bool: 0 bedeutet Norden, nicht Scheitern; 1 bedeutet Nordosten, nicht Erfolg. Übergeben Sie 100 nicht als Richtung an den Schrittbefehl.
• Die ursprünglichen Koordinaten werden von den Zielkoordinaten subtrahiert und anschließend werden die Vorzeichen der Differenzen überprüft. Abnehmendes Y bedeutet Norden, zunehmendes X bedeutet Osten. Ändern sich beide Koordinaten, wird unabhängig von der Größe der Unterschiede die Diagonale gewählt. Wenn beide Differenzen Null sind – 100.

return  RunScenario();
 object? RunScenario()
{
    var direction = UO.CalcDir(100, 100, 100, 100);
    if (Truth(direction == 100))
    {
        return "already there";
    }

    return "different point";
    return null;
}

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

Parameter und Ablauf:

• Beim Übergang von (20,20) zu (19,21) nimmt X ab und Y zu: UO.CalcDir gibt 5 zurück. RebuildDirection zeigt alle Zweige dieses Algorithmus und gibt auch 5 aus. Main gibt „5:5“ zurück. Alle vier Assistentenparameter haben die gleiche Koordinatenbedeutung.
• int – Richtungscode: 0=Norden, 1=Nordosten, 2=Osten, 3=Südosten, 4=Süden, 5=Südwesten, 6=Westen, 7=Nordwesten. Passende Punkte ergeben 100. Es ist nicht bool: 0 bedeutet Norden, nicht Scheitern; 1 bedeutet Nordosten, nicht Erfolg. Übergeben Sie 100 nicht als Richtung an den Schrittbefehl.
• Die ursprünglichen Koordinaten werden von den Zielkoordinaten subtrahiert und anschließend werden die Vorzeichen der Differenzen überprüft. Abnehmendes Y bedeutet Norden, zunehmendes X bedeutet Osten. Ändern sich beide Koordinaten, wird unabhängig von der Größe der Unterschiede die Diagonale gewählt. Wenn beide Differenzen Null sind – 100.

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 actual = UO.CalcDir(20, 20, 19, 21);
        var rebuilt = RebuildDirection(20, 20, 19, 21);
        return Convert.ToString(actual) + ":" + Convert.ToString(rebuilt);
        return null;
    }

    dynamic RebuildDirection(dynamic Xfrom, dynamic Yfrom, dynamic Xto, dynamic Yto)
    {
        var dx = Xto - Xfrom;
        var dy = Yto - Yfrom;
        if (Truth(dx == 0) && Truth(dy == 0))
        {
            return 100;
        }

        if (Truth(dx == 0))
        {
            if (Truth(dy < 0))
            {
                return 0;
            }

            return 4;
        }

        if (Truth(dy == 0))
        {
            if (Truth(dx > 0))
            {
                return 2;
            }

            return 6;
        }

        if (Truth(dx > 0))
        {
            if (Truth(dy < 0))
            {
                return 1;
            }

            return 3;
        }

        if (Truth(dy > 0))
        {
            return 5;
        }

        return 7;
    }

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

C# unterscheidet Groß- und Kleinschreibung. Verwenden Sie den genauen UO-Namen. Numerische Flags mit 0 vergleichen; bool nur bei Rückgabetyp bool verwenden.

Parameter: xfrom (Any), yfrom (Any), xto (Any), yto (Any)

Ergebnis: int / Integer.

Beim Aufruf:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• InjectionScript.Runtime.InjectionApiUO.CalculateDirection: CalculateDirection(Arg(0), Arg(1), Arg(2), Arg(3)).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).

Interner Implementierungscode; kein eigenständiges Skript.

case "calcdir": return new InjectionValue(CalculateDirection(Arg(0), Arg(1), Arg(2), Arg(3)));

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

void UO.CancelMove();

Deaktiviert die weitere Bewegung durch das Skript über MoveOff.

Es gibt keine Parameter.

void – kein Rückgabewert.

• Ruft MoveOff auf, wodurch die Laufzeit/der Manager in den Zustand MoveEnabled=false versetzt wird. Um die Bewegung wieder zu ermöglichen, ist MoveOn erforderlich. Der Befehl setzt bereits gesendete Schritte nicht zurück.

Jedes Beispiel kann als separate Datei .csx gespeichert und in IDE ausgeführt werden. Die UO-Objekt- und Wartefunktionen stellen den Host der aktuellen Spielsitzung bereit. Ersetzen Sie Demo-serial-Namen, Koordinaten und Adressen durch Ihre eigenen.

Führe diesen Code als eigene .csx-Datei aus. Die Argumente stehen direkt im Aufruf; ersetze Beispielnamen, Serials und Adressen durch eigene Werte.

Der Befehl steht in einer eigenen Anweisung. Die Meldung davor zeigt den Beginn des Aufrufs und bestätigt keine Serveraktion.

UO.Print("Calling UO.CancelMove");
UO.CancelMove();

Parameter und Ablauf:

• Die folgenden Bewegungsbefehle berücksichtigen die ausgeschaltete Auflösung.

UO.CancelMove();

Parameter und Ablauf:

• MoveOn stellt die Auflösung explizit wieder her.

return  RunScenario();
 object? RunScenario()
{
    UO.CancelMove();
    UO.MoveOn();
    return null;
}

Parameter und Ablauf:

• Eine getrennte Verbindung wird als Bedingung verwendet, um weitere Schritte zu verhindern.

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

     public object? RunScenario()
    {
        if (!(Truth(UO.Connected())))
        {
            UO.CancelMove();
        }

        return null;
    }

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

C# unterscheidet Groß- und Kleinschreibung. Verwenden Sie den genauen UO-Namen. Numerische Flags mit 0 vergleichen; bool nur bei Rückgabetyp bool verwenden.

Parameter: Keine Parameter.

Ergebnis: void / Unit.

Beim Aufruf:

• InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
• InjectionScript.Runtime.InjectionApiUO.MoveOff: MoveOff().

Interner Implementierungscode; kein eigenständiges Skript.

case "cancelmove": MoveOff(); break;

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

int UO.Dir();

Liest die Zeichenrichtung aus dem Clientmodell.

Es gibt keine Parameter.

int — Richtung mobile ohne Laufbit: 0=N, 1=NE, 2=E, 3=SE, 4=S, 5=SW, 6=W, 7=NW. Für unbekannt gibt mobile 0 zurück, was ebenfalls Norden bedeutet.

• Bereits empfangene lokale Daten werden gelesen. Die Anfrage öffnet den Status nicht und zwingt den Server nicht, ein Update zu senden. Nach einem Tod, einem Kartenübergang oder einer Objektlöschung können sich die Werte zwischen zwei Aufrufen ändern.
• C# unterscheidet Groß- und Kleinschreibung. Verwenden Sie den genauen UO-Namen. Numerische Flags mit 0 vergleichen; bool nur bei Rückgabetyp bool verwenden.

Jedes Beispiel kann als separate Datei .csx gespeichert und in IDE ausgeführt werden. Die UO-Objekt- und Wartefunktionen stellen den Host der aktuellen Spielsitzung bereit. Ersetzen Sie Demo-serial-Namen, Koordinaten und Adressen durch Ihre eigenen.

Führe diesen Code als eigene .csx-Datei aus. Die Argumente stehen direkt im Aufruf; ersetze Beispielnamen, Serials und Adressen durch eigene Werte.

Das Ergebnis eines Aufrufs wird im Journal ausgegeben. Zahlen werden nicht in bool umgewandelt; bei Arrays wird die Anzahl der Elemente angezeigt.

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

Parameter und Ablauf:

• Der Aufruf ohne Argumente bezieht sich auf self. Die Richtung des Zeichens wird im Wert gespeichert.
• Convert.ToString wandelt die auszugebende Zahl um und ändert die Bedeutung des Ergebnisses nicht.

var value = UO.Dir();
UO.Print("Dir: " + Convert.ToString(value));

Parameter und Ablauf:

• Der Wert wird einmal ohne Argumente gelesen. Die Richtung des Zeichens wird in der angezeigten Berechnung oder Bedingung verwendet.
• Numerische Schwellenwerte sind Beispiele für Skriptbedingungen und keine neuen Client-Grenzwerte. Das Feld speichert die oben beschriebenen Servereinheiten und Einschränkungen.

return  RunScenario();
 object? RunScenario()
{
    var value = UO.Dir();
    if (Truth(value == 2))
    {
        UO.Print("Facing east");
    }

    return null;
}

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

Parameter und Ablauf:

• Beide Aufrufe ohne Argument lesen ihren aktuellen Wert. UO.Wait(1000) gibt eine Pause in Millisekunden zwischen den Aufnahmen.
• Änderung im Vergleich: Zeichenrichtung. Ein Beispiel ändert nichts auf der Welt und wartet nicht endlos. Ereignisse innerhalb dieser Sekunde können übersehen werden.

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 before = UO.Dir();
        await Delay(1000);
        var after = UO.Dir();
        if (Truth(before != after))
        {
            UO.Print("Before: " + Convert.ToString(before) + "; after: " + Convert.ToString(after));
        }

        return null;
    }

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

C# unterscheidet Groß- und Kleinschreibung. Verwenden Sie den genauen UO-Namen. Numerische Flags mit 0 vergleichen; bool nur bei Rückgabetyp bool verwenden.

Parameter: Keine Parameter.

Ergebnis: int / Integer.

Beim Aufruf:

• InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [Dir].
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetDir: bridge.GetDir(bridge.Self).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self: bridge.Self.

Der Aufruf führt den gespeicherten Handler-Delegate aus. Die Registrierungsmethode erzeugt ihn beim Aufbau der API.

Interner Implementierungscode; kein eigenständiges Skript.

() => bridge.GetDir(bridge.Self)

API-Erstellung: Diese Funktionen registrieren die API. Sie werden nicht bei jedem Befehlsaufruf erneut ausgeführt.

• InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddInteger.

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

int UO.Direction();

Liest die Zeichenrichtung aus dem Clientmodell.

Es gibt keine Parameter.

int — Richtung mobile ohne Laufbit: 0=N, 1=NE, 2=E, 3=SE, 4=S, 5=SW, 6=W, 7=NW. Für unbekannt gibt mobile 0 zurück, was ebenfalls Norden bedeutet.

• Bereits empfangene lokale Daten werden gelesen. Die Anfrage öffnet den Status nicht und zwingt den Server nicht, ein Update zu senden. Nach einem Tod, einem Kartenübergang oder einer Objektlöschung können sich die Werte zwischen zwei Aufrufen ändern.
• C# unterscheidet Groß- und Kleinschreibung. Verwenden Sie den genauen UO-Namen. Numerische Flags mit 0 vergleichen; bool nur bei Rückgabetyp bool verwenden.

Jedes Beispiel kann als separate Datei .csx gespeichert und in IDE ausgeführt werden. Die UO-Objekt- und Wartefunktionen stellen den Host der aktuellen Spielsitzung bereit. Ersetzen Sie Demo-serial-Namen, Koordinaten und Adressen durch Ihre eigenen.

Führe diesen Code als eigene .csx-Datei aus. Die Argumente stehen direkt im Aufruf; ersetze Beispielnamen, Serials und Adressen durch eigene Werte.

Das Ergebnis eines Aufrufs wird im Journal ausgegeben. Zahlen werden nicht in bool umgewandelt; bei Arrays wird die Anzahl der Elemente angezeigt.

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

Parameter und Ablauf:

• Der Aufruf ohne Argumente bezieht sich auf self. Die Richtung des Zeichens wird im Wert gespeichert.
• Convert.ToString wandelt die auszugebende Zahl um und ändert die Bedeutung des Ergebnisses nicht.

var value = UO.Direction();
UO.Print("Direction: " + Convert.ToString(value));

Parameter und Ablauf:

• Der Wert wird einmal ohne Argumente gelesen. Die Richtung des Zeichens wird in der angezeigten Berechnung oder Bedingung verwendet.
• Numerische Schwellenwerte sind Beispiele für Skriptbedingungen und keine neuen Client-Grenzwerte. Das Feld speichert die oben beschriebenen Servereinheiten und Einschränkungen.

return  RunScenario();
 object? RunScenario()
{
    var value = UO.Direction();
    if (Truth(value == 2))
    {
        UO.Print("Facing east");
    }

    return null;
}

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

Parameter und Ablauf:

• Beide Aufrufe ohne Argument lesen ihren aktuellen Wert. UO.Wait(1000) gibt eine Pause in Millisekunden zwischen den Aufnahmen.
• Änderung im Vergleich: Zeichenrichtung. Ein Beispiel ändert nichts auf der Welt und wartet nicht endlos. Ereignisse innerhalb dieser Sekunde können übersehen werden.

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 before = UO.Direction();
        await Delay(1000);
        var after = UO.Direction();
        if (Truth(before != after))
        {
            UO.Print("Before: " + Convert.ToString(before) + "; after: " + Convert.ToString(after));
        }

        return null;
    }

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

C# unterscheidet Groß- und Kleinschreibung. Verwenden Sie den genauen UO-Namen. Numerische Flags mit 0 vergleichen; bool nur bei Rückgabetyp bool verwenden.

Parameter: Keine Parameter.

Ergebnis: int / Integer.

Beim Aufruf:

• InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases [Direction].
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetDir: bridge.GetDir(bridge.Self).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self: bridge.Self.

Der Aufruf führt den gespeicherten Handler-Delegate aus. Die Registrierungsmethode erzeugt ihn beim Aufbau der API.

Interner Implementierungscode; kein eigenständiges Skript.

() => bridge.GetDir(bridge.Self)

API-Erstellung: Diese Funktionen registrieren die API. Sie werden nicht bei jedem Befehlsaufruf erneut ausgeführt.

• InjectionScript.Runtime.InjectionApiUO.RegisterCharacterGetterAliases::AddInteger.

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

void UO.FixWalk();

Gibt einen Hinweis aus, dass der ältere native Client-Patch FixWalk von ClassicUO nicht benötigt wird.

Es gibt keine Parameter.

void – kein Rückgabewert.

• Der Zweig ExecuteLegacyManualAlias ruft nur SystemMessage auf. Bewegung, Sprache, Container oder Netzwerkprotokoll werden nicht korrigiert.

Jedes Beispiel kann als separate Datei .csx gespeichert und in IDE ausgeführt werden. Die UO-Objekt- und Wartefunktionen stellen den Host der aktuellen Spielsitzung bereit. Ersetzen Sie Demo-serial-Namen, Koordinaten und Adressen durch Ihre eigenen.

Führe diesen Code als eigene .csx-Datei aus. Die Argumente stehen direkt im Aufruf; ersetze Beispielnamen, Serials und Adressen durch eigene Werte.

Der Befehl steht in einer eigenen Anweisung. Die Meldung davor zeigt den Beginn des Aufrufs und bestätigt keine Serveraktion.

UO.Print("Calling UO.FixWalk");
UO.FixWalk();

Parameter und Ablauf:

• Die Meldung beschreibt, dass der alte Patch nicht benötigt wird.

UO.FixWalk();

Parameter und Ablauf:

• Das Kompatibilitätsverfahren verändert die Spielwelt nicht.

return  RunScenario();
 object? RunScenario()
{
    CompatibilityNotice();
    return null;
}

void CompatibilityNotice()
{
    UO.FixWalk();
}

Parameter und Ablauf:

• Nach der Diagnosemeldung wird die Ausführung fortgesetzt.

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.FixWalk();
        UO.Print("continued");
        return null;
    }
}

C# unterscheidet Groß- und Kleinschreibung. Verwenden Sie den genauen UO-Namen. Numerische Flags mit 0 vergleichen; bool nur bei Rückgabetyp bool verwenden.

Parameter: Keine Parameter.

Ergebnis: void / Unit.

Beim Aufruf:

• InjectionScript.Runtime.InjectionApiUO.ExecuteLegacyManualAlias.
• InjectionScript.Runtime.InjectionApiUO.SystemMessage: SystemMessage($"{name}: obsolete native-client patch; ClassicUO does not require it.").

Interner Implementierungscode; kein eigenständiges Skript.

case "boxhack":

                case "fixtalk":

                case "fixwalk":

                    SystemMessage($"{name}: obsolete native-client patch; ClassicUO does not require it.");

                    break;

Follow verwendet UO.LimitMove, moveCheckStamina, moveOpenDoor, moveThroughCorner, moveThroughNPC, moveHeuristicMult, moveTurnCost, moveExitOnDisconnect, moveBetweenTwoCorners sowie einen Schnappschuss von SetBadLocation/SetBadObject. Annäherungsabstand 0 gilt auch für Figuren; er ist unabhängig von UO.LimitMove.

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

int UO.Follow();
int UO.Follow(object? target);
int UO.Follow(object? target, object? distance);
int UO.Follow(object? target, object? distance, object? running);
int UO.Follow(object? target, object? distance, object? running, object? stopConditions);
int UO.Follow(object? x, object? y, object? z, object? distance, object? running);
int UO.Follow(object? x, object? y, object? z, object? distance, object? running, object? stopConditions);

Ermöglicht die Hintergrundverfolgung des geladenen Zeichens/NPC oder die Bewegung zu den Punkten X, Y, Z. Während der Bewegung prüft der Client die übermittelten Stoppbedingungen; Das Skript setzt die Ausführung unmittelbar nach dem Aufruf fort.

• target – Zeichenserie/NPC: int, Hexadezimal-/Dezimalzeichenfolge, lasttarget oder Name, der zuvor über AddObject gespeichert wurde. Dabei handelt es sich nicht um graphic/type oder Koordinaten. Sie können weder sich selbst noch einem Objekt folgen. 0 folgt nicht mehr. Ohne Argumente stoppt Follow() es auch; der Anblick erscheint nicht.
• distance – X/Y-Toleranz in Zellen: maximal |dx| und |dy|. Für Zeichen int 0..18, Standard 1; Z-Unterschiede bis zu 16 sind akzeptabel. Für den Punkt int 0..18 ist das Argument erforderlich: 0 erfordert exaktes X/Y, 2 ermöglicht das Anhalten innerhalb von zwei Zellen; Z muss genau übereinstimmen. Ein ungültiger Wert ersetzt nicht das bisherige Verhalten.
• running – bool-kompatibler Wert: true/1 – Laufen, false/0 – Gehen; Der Standardwert ist true. Geschwindigkeitsbegrenzungen, Ausdauer, Lähmungen und Hindernisse des Servers bleiben bestehen. Das Flag beschleunigt die Serverschritte nicht.
• stopConditions – Optionales Array von Stoppbedingungen: viertes Argument für Zeichen, sechstes für Koordinaten. Jedes Element ist ein Array aus genau drei Werten [Feld, Vergleich, Schwellenwert]. Feld und Vergleich sind Zeichenfolgen, Schwellenwert ist int/double; für Fahnen sind true/false (1/0) geeignet. Das Auslösen JEDER Bedingung beendet Follow (OR). Ein leeres Array fügt keine Bedingungen hinzu. Die Anzahl der Elemente ist nicht auf feste 3/5/10-Elemente beschränkt, sondern wird durch den Speicher begrenzt; Große Listen werden in Blöcken überprüft. Zulässige Felder und Einheiten sind unten aufgeführt; Ein unbekanntes Feld, ein unbekannter Operator oder eine ungültige Array-Form verursacht einen Fehler, bevor das frühere Follow ersetzt wird.
• x – Nur Formulare mit 5/6-Argumenten: ganzzahlige Weltkoordinaten auf der aktuellen Karte, 0..65535 und innerhalb geladener Kartengrenzen. Dies sind keine Fenster-/Gump-Koordinaten oder serial. Eine Übertragung auf eine andere Karte erfolgt nicht.
• y – Nur Formulare mit 5/6-Argumenten: ganzzahlige Weltkoordinaten auf der aktuellen Karte, 0..65535 und innerhalb geladener Kartengrenzen. Dies sind keine Fenster-/Gump-Koordinaten oder serial. Eine Übertragung auf eine andere Karte erfolgt nicht.
• z – Nur Formulare mit 5/6-Argumenten: ganzzahlige Welthöhe -128..127. Diese Höhe ist für die Fertigstellung erforderlich. Geben Sie daher den Z-Wert der verfügbaren Oberfläche des gewünschten Bodens an. Es gibt keine separaten „beliebigen Z“-Werte oder eine automatische Höhenauswahl.

int 1 (true) – der folgende Modus wurde vom Client akzeptiert oder eine Stoppanforderung wurde abgeschlossen; int 0 (false) – Es ist kein passender Charakter geladen, der Spieler ist nicht verfügbar/tot, das Ziel ist außer Sichtweite, die Entfernung ist falsch oder der Client unterstützt das Team nicht. Dies ist nicht das Ergebnis der Ankunft, nicht serial und nicht der Anzahl der Schritte. Verwenden Sie in C# if (result != 0) oder if (result == 1); Das Ergebnis ist vom Typ int, nicht bool. Typfehler/unbekannter Objektname können einen Skriptfehler verursachen. Bei Koordinaten bedeutet 0 auch ungültige X/Y/Z oder Toleranz. 1 bedeutet, nur die Hintergrundaufgabe zu akzeptieren; Ankunft und zukünftige Belegung müssen noch bestätigt werden.

• Genau ein Follow-Modus pro Client: Zeichen oder Koordinaten. Ein erfolgreicher Aufruf ersetzt erneut das Ziel und die Parameter. Eine erfolglose Herausforderung hebt das vorherige Ziel nicht auf. Um einem Charakter zu folgen, muss er sich bereits in der geladenen Mobiles-Liste innerhalb von ClientViewRange befinden; Der Koordinatenpunkt liegt möglicherweise weiter als die Ansicht.
• Wenn die Figur in die Nähe des Ziels gelangt, stoppt das Gehen, der Modus bleibt jedoch aktiviert und setzt die Bewegung fort, wenn sich das Ziel entfernt. In der Nähe des Bezugspunkts wird die Aufgabe abgeschlossen, wenn die X/Y-Toleranz und das exakte Z eingehalten werden. Der Befehl meldet beim Start keine garantierte Erreichbarkeit der Route.
• Follow(), Follow(0), MoverStop(), manuelle Maus-/Pfeilbewegung, eine neue Skriptroute oder Standard-Client-Folgen beenden diesen Modus. TerminateAll/Terminate("all") stoppt es ebenfalls. Wenn Sie ein noch laufendes Eigentümerskript abbrechen, wird es gestoppt Follow.
• Beide Modi enden, wenn sich die Karte oder der Charakter ändert, der Spieler stirbt oder die Verbindung unterbrochen wird. Das Verfolgen des Charakters stoppt außerdem, wenn das Ziel aus dem Speicher/der Ansicht verschwindet. Das spätere Erscheinen eines Ziels löst den Modus nicht automatisch aus: Es ist ein neues Follow erforderlich.
• Das Schließen von IDE beendet den Modus nicht. Bei normaler Beendigung eines laufenden Skripts bleibt Follow aktiviert. Eine Skriptpause ist selbst keine Pause für diesen Clientmodus; Verwenden Sie vor dem Anhalten Follow(0), wenn die Bewegung angehalten werden muss.
• Pathfinder berechnet den Pfad in Blöcken im Spielstream; Eine unvollständige Suche wird nicht erneut gestartet. Für mobile ist die normale Routenaktualisierung auf 500 ms begrenzt. Nach einem Ausfall oder Abbruch einer Route ohne Annäherung betragen die ersten drei Wiederholungsverzögerungen 1000 ms, dann 2000, 4000 und maximal 5000 ms. Der Absprungzähler wird zurückgesetzt, wenn der X/Y/Z Spieler oder das Ziel wechselt; Durch Ändern des Ziels kann die Wartezeit um bis zu 500 ms verkürzt werden. Es gibt keine allgemeine Begrenzung für die Anzahl der Wiederholungen für ein verfügbares mobile-Ziel: Der Modus kann aktiv bleiben, ohne sich zu bewegen, also stellen Sie ihn auf „verstrichen“ oder stoppen Sie ihn explizit. Die Koordinatenaufgabe endet, wenn der Pfad vollständig ausfällt.
• Entfernungs-/Zeitfelder: Entfernung – aktuelle Entfernung zum Ziel in Zellen max(abs(dx),abs(dy)); Höhe – absolute Differenz Z in Welteinheiten; verstrichen – Millisekunden seit der Annahme dieses Follow. Distanz > 12 stoppt, wenn man sich weiter als 12 Zellen bewegt, verstrichen >= 30000 - nach 30 Sekunden. Ein wiederholtes erfolgreiches Follow startet den Countdown erneut.
• Der Zustand deines Charakters: self.hp / self.mana / self.stam – aktuelle Werte; self.hppercent / self.manapercent / self.stampercent – ​​Prozentsätze 0..100 vom entsprechenden Maximum. Unbekanntes Maximum (<=0) bedeutet unbekannten Wert: Die Bedingung für dieses Merkmal wird nicht ausgelöst, anstatt den fiktiven 0 zu erhalten.
• Logische Felder für deinen Charakter: self.poisoned (vergiftet), self.paralyzed (gelähmt), self.hidden (versteckt). Werte 1/0. Im Bedingungsarray Follow folgt die Regel für das Feld „self.paralyzed“ mit dem Operator „=" und dem Wert true nicht mehr, wenn sie paralysiert ist. Dies ist der Stringname des Regelfelds, nicht die C#-Variable self.
• Zielfelder: target.dead – tot mobile, target.hidden – ausgeblendet, target.visible – für den Client sichtbar (nicht CheckLOS), target.hp / target.hppercent – ​​geladen HP/percent. Wenn HP max unbekannt ist, schlägt die HP-Bedingung fehl. Der Server kann die relative Skala HP des Charakters einer anderen Person senden, daher ist hppercent für ihn bequemer.
• Zusätzliche Zielfelder: target.notoriety – Status 0..7 (0 unbekannt, 1 unschuldig, 2 Verbündeter, 3 grau, 4 kriminell, 5 Feind, 6 Mörder, 7 Unverwundbar); Ziel.body – numerischer graphic des Körpers. Es handelt sich hierbei nicht um type-Kleidung. Beispielsweise stoppt target.notoriety != 2 die Verfolgung, wenn der Verbündetenstatus verloren geht.
• Beim Aufruf wird eine Kopie der Bedingungen erfasst, einschließlich numerischer Schwellenwerte. Durch das Ändern des Quellarrays/der Quellvariablen wird der Modus nicht aktualisiert; Wiederholen Sie Follow mit dem neuen Array. Der abgebrochene Modus wird nicht selbst wieder aufgenommen, wenn die Bedingung nicht mehr erfüllt ist.
• Die Bedingungen werden sowohl während der Bewegung als auch dann überprüft, wenn der Charakter bereits in der Nähe des Ziels steht. Eine reguläre Liste von bis zu 64 Elementen wird in einem Spielrahmen überprüft, die nächste Überprüfung erfolgt nicht früher als nach 250 ms. Eine größere Liste – 64 Elemente pro Frame, dann eine Pause 250 ms. Das abgelaufene Feld stoppt möglicherweise später als der Schwellenwert für die Dauer der Prüfung/des Frames: Es handelt sich nicht um einen genauen Timer.
• Bis die erste Prüfung der gesamten Liste abgeschlossen ist, beginnt keine neue Route. Wenn die Bedingung bereits erfüllt ist, gibt Follow 1 für die akzeptierte Anfrage zurück und stoppt dann die Aktualisierung ohne den ersten Schritt. Möglicherweise wurden bereits Pakete mit Schritten aus der vorherigen Bewegung gesendet.
• Durch die neuen Bedingungen werden obligatorische Stoppgründe nicht deaktiviert: Verlust von Ziel/Spieler/Karte/Link, Spielertod, Löschung des Besitzers, Terminate alle und manuelle/sonstige Bewegung. Skriptcode wird im Spielthread nicht ausgeführt; Es werden nur die aufgeführten lokalen Werte überprüft.
• Koordinatenformen: Follow(x,y,z,distance,running) und Follow(x,y,z,distance,running,stopConditions). Die ersten fünf Argumente sind erforderlich. Follow(x,y,z) ist keine Abkürzung für Koordinaten: Die drei Argumente bedeuten immer noch Ziel, Entfernung, Laufen.
• Im Koordinatenmodus bedeutet „Abstand“ in der Bedingung den verbleibenden X/Y-Abstand zum Punkt, die Höhe ist die absolute Differenz von seinem Z-Wert; abgelaufen und alle self.* funktionieren wie gewohnt. Die Felder „target.*“ sind ungültig: Der Punkt hat keinen HP, Körper oder Status. Der Versuch, sie zu übergeben, führt zu einem Skriptfehler, bis der alte Modus ersetzt wird.
• Die Bedingungen werden vor der ersten Route, während ihrer Berechnung und während der Bewegung des Charakters überprüft. Das Auslösen einer beliebigen Bedingung entfernt die Aufgabe und bricht den zugehörigen Pfad ab. Die Häufigkeit und Verarbeitung großer Listen entspricht dem Verfolgen eines Zeichens. Schritte, die bereits an den Server gesendet wurden, werden möglicherweise abgeschlossen.
• Die Koordinatenaufgabe endet, wenn der Punkt erreicht ist oder die Suche und Bewegung fehlschlägt bzw. endet, ohne ihn zu erreichen. Unendliche Wiederholungsversuche zu einem nicht erreichbaren Punkt werden nicht ausgelöst. Die normalen internen Neuberechnungen von Pathfinder für Hindernisse bleiben erhalten. Sobald der Vorgang abgeschlossen ist, wird die Aufgabe durch das Verlassen des Standorts nicht fortgesetzt.
• Wenn Pathfinder die letzten Schritte bereits gesendet und den Pfad abgeschlossen hat, diese Schritte jedoch noch ausgeführt werden/auf Bestätigung warten, prüft die Aufgabe weiterhin die Bedingungen. Die Warteschlange der gesendeten Schritte selbst wird nicht gelöscht: Sie muss vom normalen Serverbewegungs- und Bestätigungsmechanismus verarbeitet werden.
• Die Liste kann über List.Add am DO ... Ende der Schleife oder FOR zusammengestellt und dann einmal an checks.ToArray() als letztes Argument der entsprechenden Form übergeben werden. Es ist nicht erforderlich, Follow bei jeder Iteration erneut aufzurufen: Dadurch wird der Modus ersetzt und die verstrichenen Werte zurückgesetzt. Die Anzahl der Zeilen ist nicht auf eine geringe Anzahl beschränkt, der Satz unterstützter Felder ist jedoch auf die oben aufgeführten Felder beschränkt.
• Nach 2000 ms ohne Änderung von X/Y/Z können Spieler mobile-Follow erneut einen Pfad zu einem stationären Ziel anfordern. Die Prüfung wird nur durchgeführt, wenn der nächste Termin außerhalb der Suche eintritt, nachdem Player.Steps und die Walker-Warteschlange freigegeben wurden und der nächste Schritt zulässig ist. Es entstehen keine Kosten, langsam voranzukommen und auf Bestätigungen zu warten; Gesendete Schritte werden nicht gelöscht. Die Koordinate Follow löst keine solche externe unendliche Wiederholung aus: Die Wiederherstellung ihres Pfades wird vom eingeschränkten Pathfinder übernommen.
• Der allgemeine Pathfinder speichert bis zu 8 temporäre X/Y/Z-Richtungsverbote für 2000 ms, nur bei abgelehnter Bewegung der entsprechenden aktiven Anfrage. Rotation, unbekannte Reihenfolge, Resynchronisation und Alt-/Fremdanfrage begründen kein solches Verbot. Durch eine neue externe Anfrage und den Verlust des Karten-/Spielerkontexts werden sie gelöscht. Die Suche nach geladener Geometrie versucht, den Übergang zu umgehen; Es geht darum, nicht alle Serverhindernisse zu kennen. Ohne die X/Y/Z des Spielers zu ändern, sind bis zu 8 interne Neuberechnungen mit einer Pause von mindestens 40 ms zulässig. Es gibt keinen vollständigen Weg oder dieses Budget ist erschöpft – die Route endet. Die Koordinatenaufgabe wird dann abgeschlossen, nachdem die übermittelten Schritte verarbeitet wurden. mobile-Follow versucht es aufgrund der Verzögerung möglicherweise erneut.
• Der Controller vergleicht die Nummer seiner eigenen Bewegungsanforderung, nicht die Tatsache AutoWalking: Das natürliche Ende des Pfades wird nicht als Fremdbefehl betrachtet. StopOwnedPath überträgt die gespeicherte Nummer an StopAutoWalkIfRequestGeneration. Die neue externe Anfrage beendet das alte Follow; Durch das Stoppen wird die neue Route einer anderen Person nicht gelöscht.

Jedes Beispiel kann als separate Datei .csx gespeichert und in IDE ausgeführt werden. Die UO-Objekt- und Wartefunktionen stellen den Host der aktuellen Spielsitzung bereit. Ersetzen Sie Demo-serial-Namen, Koordinaten und Adressen durch Ihre eigenen.

Führe diesen Code als eigene .csx-Datei aus. Die Argumente stehen direkt im Aufruf; ersetze Beispielnamen, Serials und Adressen durch eigene Werte.

Das Ergebnis eines Aufrufs wird im Journal ausgegeben. Zahlen werden nicht in bool umgewandelt; bei Arrays wird die Anzahl der Elemente angezeigt.

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

Parameter und Ablauf:

• Anführer – serial des letzten Ziels. Die Einheit bestätigt die Annahme des Regimes, nicht die Ankunft. Nach Beendigung der Methode arbeitet der Modus weiter, bis das Ziel stoppt/verliert.

var leader = UO.GetSerial("lasttarget");
var accepted = UO.Follow(leader);
if (Truth(Truth(accepted) == true))
{
    UO.Print("Following is enabled; script continues");
}
else
{
    UO.Print("Select a loaded nearby character");
}

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

Parameter und Ablauf:

• UO.Wait wird in Millisekunden gemessen. Follow(0) schaltet den allgemeinen Folgemodus aus; Nachfolgende Bewegungen des Ziels verursachen keine Bewegung mehr.

return await RunScenarioAsync();
async Task<object?> RunScenarioAsync()
{
    var leader = UO.GetSerial("lasttarget");
    if (Truth(UO.Follow(leader, 3, false) == 1))
    {
        await Delay(10000);
        UO.Follow(0);
        UO.Print("Following stopped");
    }

    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;

Parameter und Ablauf:

• Distanz=2, Laufen=true; maximale 20-Erwartungen über 500 ms. Exists prüft die Anwesenheit eines Objekts, nicht jedoch die Erreichbarkeit des Pfades. finally stoppt den Modus während des normalen Beendens/Fehlers; Die Notfallstornierung durch den Eigentümer erfolgt zusätzlich durch den Kunden.

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 leader = UO.GetSerial("leader");
        if (Truth(UO.Follow(leader, 2, true) == 0))
        {
            UO.Print("Cannot start following");
            return null;
        }

        try
        {
            var attempts = 0;
            while (Truth(attempts < 20) && Truth(UO.Exists(leader)))
            {
                await Delay(500);
                attempts = attempts + 1;
            }
        }
        finally
        {
            UO.Follow();
        }

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

Parameter und Ablauf:

• Anhalten unter JEDER Bedingung: Das Ziel ist weiter als 12 Zellen ODER unser HP nicht mehr als 40% ODER 30 Sekunden sind vergangen. Das ist nicht AND. StopWhen ist vollständig angegeben, es kann in Include eingebunden werden. Eins bedeutet Akzeptanz, nicht Ankunft.

var leader = UO.GetSerial("lasttarget");
dynamic[] conditions = new dynamic[checked((int)(2) + 1)];
conditions[0] = StopWhen("distance", ">", 12);
conditions[1] = StopWhen("self.hppercent", "<=", 40);
conditions[2] = StopWhen("elapsed", ">=", 30000);
var accepted = UO.Follow(leader, 2, true, conditions);
if (Truth(accepted == 0))
{
    UO.Print("Cannot follow this target");
}

dynamic StopWhen(dynamic field, dynamic comparison, dynamic threshold)
{
    dynamic[] rule = new dynamic[checked((int)(2) + 1)];
    rule[0] = field;
    rule[1] = comparison;
    rule[2] = threshold;
    return rule;
}

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

Parameter und Ablauf:

• Wir hören auf, wenn das Ziel verschwunden ist/gestorben ist/kein Verbündeter mehr ist, nicht mehr als 5 Ausdauer übrig ist oder die Differenz in Z 16 überschritten hat. false bedeutet gehen. ToArray übergibt eine Liste von Bedingungszeilen; Die Größe wird nicht im Voraus angegeben. Wenn das Ziel kein Verbündeter mehr ist, beginnt die Bewegung nicht.

return  RunScenario();
 object? RunScenario()
{
    var checks = new List<object?>();
    checks.Add(StopWhen("target.hidden", "=", true));
    checks.Add(StopWhen("target.dead", "=", true));
    checks.Add(StopWhen("target.notoriety", "<>", 2));
    checks.Add(StopWhen("self.stam", "<=", 5));
    checks.Add(StopWhen("height", ">", 16));
    var leader = UO.GetSerial("lasttarget");
    var conditions = checks.ToArray();
    UO.Follow(leader, 2, false, conditions);
    return null;
}

dynamic StopWhen(dynamic field, dynamic comparison, dynamic threshold)
{
    dynamic[] rule = new dynamic[checked((int)(2) + 1)];
    rule[0] = field;
    rule[1] = comparison;
    rule[2] = threshold;
    return rule;
}

Parameter und Ablauf:

• Eingehaltener Abstand 1, Stoppbedingung <=3; Bei der Überprüfung alle 250 ms kann es zu einer verzögerten Leistung kommen. Das 15000 ms-Timeout ermöglicht keine Verfolgung auf unbestimmte Zeit. Die Rückgabe von Follow bedeutet immer noch Akzeptanz und nicht das Erreichen von drei Feldern.

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

     public object? RunScenario()
    {
        dynamic[] conditions = new dynamic[checked((int)(1) + 1)];
        conditions[0] = StopWhen("distance", "<=", 3);
        conditions[1] = StopWhen("elapsed", ">=", 15000);
        UO.Follow(UO.GetSerial("lasttarget"), 1, true, conditions);
        return null;
    }

    dynamic StopWhen(dynamic field, dynamic comparison, dynamic threshold)
    {
        dynamic[] rule = new dynamic[checked((int)(2) + 1)];
        rule[0] = field;
        rule[1] = comparison;
        rule[2] = threshold;
        return rule;
    }
}

Parameter und Ablauf:

• while sammelt eine separate Bedingung für jedes Statuselement. Stoppen Sie bei Status 5 ODER 6, besitzen Sie HP <=40% ODER nach 30000 ms. Leere Status überspringen die Schleife, die nächsten beiden Bedingungen bleiben jedoch bestehen. Neue Zeilen bis Follow hinzufügen; Eine spätere Änderung an List ändert nichts an der bereits installierten Kopie. Für Hintergrundüberprüfungen muss der Schleifenkörper nicht wiederholt werden.

var statuses = new List<object?>();
statuses.Add(5);
statuses.Add(6);
var checks = new List<object?>();
var index = 0;
while (index < statuses.Count)
{
checks.Add(StopWhen("target.notoriety", "=", statuses[index]));
index += 1;
}
checks.Add(StopWhen("self.hppercent", "<=", 40));
checks.Add(StopWhen("elapsed", ">=", 30000));
var accepted = UO.Follow(UO.GetSerial("lasttarget"), 2, true, checks.ToArray());
if (Truth(accepted == 0))
{
    UO.Print("Select a loaded nearby character");
}

dynamic StopWhen(dynamic field, dynamic comparison, dynamic threshold)
{
    dynamic[] rule = new dynamic[checked((int)(2) + 1)];
    rule[0] = field;
    rule[1] = comparison;
    rule[2] = threshold;
    return rule;
}

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

Parameter und Ablauf:

• StopEscort(Leader, startedAt) gibt bool-kompatibel 1/0 zurück: Ziel über 12 Zellen hinaus ODER eigene HP <=30 ODER 30 Sekunden sind vergangen. || hinzufügen (another_condition); Für eine obligatorische Kombination aus zwei Prüfungen verwenden Sie (BedingungA && BedingungB). Unbekannt HP kann als 0 gelesen werden; Das Beispiel weigert sich dann zu starten. Während das Skript ausgeführt wird, überprüft es Ausdrücke ungefähr alle 250 ms; Durch das Anhalten des Skripts werden diese Prüfungen angehalten. Löst schließlich einen Stopp bei normalem Exit/Fehler aus; Die Stornierung durch den Eigentümer wird zusätzlich vom Kunden verfolgt. Wenn das Ziel verschwunden ist und der Client bereits gestoppt wurde Follow, endet diese Schleife zu ihren eigenen Bedingungen, spätestens bei der Timeout-Prüfung. Um nach dem Ende der Methode zu arbeiten, verwenden Sie das vierte Argument, wie in den vorherigen Beispielen.

return  RunScenario();
 object? RunScenario()
{
    var leader = UO.GetSerial("lasttarget");
    var startedAt = Now();
    if (Truth(leader == "0x00000000") || Truth(StopEscort(leader, startedAt)))
    {
        return null;
    }

    if (Truth(UO.Follow(leader, 2, true) == 0))
    {
        return null;
    }

    try
    {
        do
        {
            UO.Wait(250);
        }
        while (!StopEscort(leader, startedAt));
    }
    finally
    {
        UO.Follow(0);
    }

    return null;
}

dynamic StopEscort(dynamic leader, dynamic startedAt)
{
    return (UO.GetDistance(leader) > 12) || (UO.GetHP("self") <= 30) || (Now() - startedAt >= 30000);
}

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

Parameter und Ablauf:

• Fünf Argumente: X=1445, Y=1690, Z=0, Toleranz X/Y=0, Lauf. Rückgabe 1 bedeutet Annahme, nicht bereits abgeschlossene Ankunft. Sobald Sie dort angekommen sind, wird die Aufgabe vollständig deaktiviert. Um manuell vorzeitig anzuhalten, rufen Sie UO.Follow(0) auf.

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 accepted = UO.Follow(1445, 1690, 0, 0, true);
        if (Truth(accepted == 0))
        {
            UO.Print("Coordinate task was not accepted");
        }

        return null;
    }

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

Parameter und Ablauf:

• Bei HP <=40%, Lähmung oder nach 30 Sekunden stoppt der Client seinen aktuellen Pfad. Andernfalls endet die Aufgabe innerhalb von zwei X/Y-Zellen von (1445,1690), genau genommen bei Z=0. Die Kontrollen werden sowohl während der Wegfindung als auch während der Bewegung fortgesetzt. Dies ist keine einmalige Kontrolle vor dem Start. target.* gilt hier nicht.

var checks = new List<object?>();
checks.Add(StopWhen("self.hppercent", "<=", 40));
checks.Add(StopWhen("self.paralyzed", "=", true));
checks.Add(StopWhen("elapsed", ">=", 30000));
UO.Follow(1445, 1690, 0, 2, true, checks.ToArray());

dynamic StopWhen(dynamic field, dynamic comparison, dynamic threshold)
{
    dynamic[] rule = new dynamic[checked((int)(2) + 1)];
    rule[0] = field;
    rule[1] = comparison;
    rule[2] = threshold;
    return rule;
}

Parameter und Ablauf:

• distance=0 im Aufruf gibt eine genaue Ankunft an, aber die Bedingung distance<=3 beendet die Aufgabe früher, wenn die nächste Prüfung eine solche Entfernung feststellt. false bedeutet Gehen. Der Unterschied Z>16 oder 20000 ms stoppt die Aufgabe ebenfalls. Die Richtung garantiert keine Passierbarkeit; Ersetzen Sie den Offset durch Ihren Routenpunkt.

Mindestschrittintervall: Gehen – Gehen 400 ms, Laufen 200 ms; Reiten - Gehen 200 ms, Laufen 100 ms.

Hierbei handelt es sich um Standard-Client-Limits und nicht um automatisch definierte Einstellungen für Ihren Shard. Servergeschwindigkeit und Flugmodi werden separat gezählt. Skript-Timer können die Bewegung verlangsamen, verringern diese Grenzwerte jedoch nicht.

Schritte, Routen, Follow, Maus-/Tastensteuerung und Karte nutzen die gemeinsame Warteschlange des Charakters. Durch das Ersetzen der Route, das Abbiegen oder das Anpassen der Position durch den Server wird die verbleibende Pause nach der Schrittanforderung nicht aufgehoben. Nach der Verzögerung gibt es keinen schnellen Burst, um die verlorenen Frames auszugleichen. Das Warten auf eine Bestätigung, Hindernisse und schlechte Kommunikation können die Bewegung verlangsamen.

return  RunScenario();
 object? RunScenario()
{
    var checks = new List<object?>();
    checks.Add(StopWhen("distance", "<=", 3));
    checks.Add(StopWhen("height", ">", 16));
    checks.Add(StopWhen("elapsed", ">=", 20000));
    var x = UO.GetX("self") + 10;
    var y = UO.GetY("self");
    var z = UO.GetZ("self");
    UO.Follow(x, y, z, 0, false, checks.ToArray());
    return null;
}

dynamic StopWhen(dynamic field, dynamic comparison, dynamic threshold)
{
    dynamic[] rule = new dynamic[checked((int)(2) + 1)];
    rule[0] = field;
    rule[1] = comparison;
    rule[2] = threshold;
    return rule;
}

C# unterscheidet Groß- und Kleinschreibung. Verwenden Sie den genauen UO-Namen. Numerische Flags mit 0 vergleichen; bool nur bei Rückgabetyp bool verwenden.

Parameter: Keine Parameter.

Ergebnis: int / Integer.

Beim Aufruf:

• InjectionScript.Runtime.InjectionApiUO.Register [Follow].
• InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(values[0]).
• InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(values[1]).

Der Aufruf führt den gespeicherten Handler-Delegate aus. Die Registrierungsmethode erzeugt ihn beim Aufbau der API.

Interner Implementierungscode; kein eigenständiges Skript.

values => new InjectionValue(bridge is IApiFollowBridge follow

                        ? follow.Follow(count == 0 ? 0 : GetObject(values[0]),

                            count < 2 ? 1 : NumberConversions.ToInt(values[1]),

                            count < 3 || NumberConversions.ToInt(values[2]) != 0) : 0)

Parameter: target (Any)

Ergebnis: int / Integer.

Beim Aufruf:

• InjectionScript.Runtime.InjectionApiUO.Register [Follow].
• InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(values[0]).
• InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(values[1]).

Der Aufruf führt den gespeicherten Handler-Delegate aus. Die Registrierungsmethode erzeugt ihn beim Aufbau der API.

Interner Implementierungscode; kein eigenständiges Skript.

values => new InjectionValue(bridge is IApiFollowBridge follow

                        ? follow.Follow(count == 0 ? 0 : GetObject(values[0]),

                            count < 2 ? 1 : NumberConversions.ToInt(values[1]),

                            count < 3 || NumberConversions.ToInt(values[2]) != 0) : 0)

Parameter: target (Any), distance (Any)

Ergebnis: int / Integer.

Beim Aufruf:

• InjectionScript.Runtime.InjectionApiUO.Register [Follow].
• InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(values[0]).
• InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(values[1]).

Der Aufruf führt den gespeicherten Handler-Delegate aus. Die Registrierungsmethode erzeugt ihn beim Aufbau der API.

Interner Implementierungscode; kein eigenständiges Skript.

values => new InjectionValue(bridge is IApiFollowBridge follow

                        ? follow.Follow(count == 0 ? 0 : GetObject(values[0]),

                            count < 2 ? 1 : NumberConversions.ToInt(values[1]),

                            count < 3 || NumberConversions.ToInt(values[2]) != 0) : 0)

Parameter: target (Any), distance (Any), running (Any)

Ergebnis: int / Integer.

Beim Aufruf:

• InjectionScript.Runtime.InjectionApiUO.Register [Follow].
• InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(values[0]).
• InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(values[1]).

Der Aufruf führt den gespeicherten Handler-Delegate aus. Die Registrierungsmethode erzeugt ihn beim Aufbau der API.

Interner Implementierungscode; kein eigenständiges Skript.

values => new InjectionValue(bridge is IApiFollowBridge follow

                        ? follow.Follow(count == 0 ? 0 : GetObject(values[0]),

                            count < 2 ? 1 : NumberConversions.ToInt(values[1]),

                            count < 3 || NumberConversions.ToInt(values[2]) != 0) : 0)

Parameter: target (Any), distance (Any), running (Any), stopConditions (Any)

Ergebnis: int / Integer.

Beim Aufruf:

• InjectionScript.Runtime.InjectionApiUO.Register [Follow].
• InjectionScript.Runtime.FollowStopCondition.Parse: FollowStopCondition.Parse(values[3]).
• InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(values[0]).
• InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(values[1]).
• InjectionScript.Runtime.InjectionApiUO.ToBoolean: ToBoolean(values[2]).

Der Aufruf führt den gespeicherten Handler-Delegate aus. Die Registrierungsmethode erzeugt ihn beim Aufbau der API.

Interner Implementierungscode; kein eigenständiges Skript.

values =>

                {

                    FollowStopCondition[] conditions = FollowStopCondition.Parse(values[3]);

                    return new InjectionValue(bridge is IApiConditionalFollowBridge follow

                        ? follow.Follow(GetObject(values[0]), NumberConversions.ToInt(values[1]), ToBoolean(values[2]), conditions) : 0);

                }

Parameter: x (Any), y (Any), z (Any), distance (Any), running (Any)

Ergebnis: int / Integer.

Beim Aufruf:

• InjectionScript.Runtime.InjectionApiUO.Register [Follow].
• InjectionScript.Runtime.FollowStopCondition.Parse: FollowStopCondition.Parse(values[5], coordinateGoal: true).
• InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(values[0]).
• InjectionScript.Runtime.InjectionApiUO.ToBoolean: ToBoolean(values[4]).

Der Aufruf führt den gespeicherten Handler-Delegate aus. Die Registrierungsmethode erzeugt ihn beim Aufbau der API.

Interner Implementierungscode; kein eigenständiges Skript.

values =>

                    {

                        FollowStopCondition[] conditions = count == 6

                            ? FollowStopCondition.Parse(values[5], coordinateGoal: true) : Array.Empty<FollowStopCondition>();

                        return new InjectionValue(bridge is IApiCoordinateFollowBridge follow

                            ? follow.FollowPoint(NumberConversions.ToInt(values[0]), NumberConversions.ToInt(values[1]),

                                NumberConversions.ToInt(values[2]), NumberConversions.ToInt(values[3]), ToBoolean(values[4]), conditions) : 0);

                    }

Parameter: x (Any), y (Any), z (Any), distance (Any), running (Any), stopConditions (Any)

Ergebnis: int / Integer.

Beim Aufruf:

• InjectionScript.Runtime.InjectionApiUO.Register [Follow].
• InjectionScript.Runtime.FollowStopCondition.Parse: FollowStopCondition.Parse(values[5], coordinateGoal: true).
• InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(values[0]).
• InjectionScript.Runtime.InjectionApiUO.ToBoolean: ToBoolean(values[4]).

Der Aufruf führt den gespeicherten Handler-Delegate aus. Die Registrierungsmethode erzeugt ihn beim Aufbau der API.

Interner Implementierungscode; kein eigenständiges Skript.

values =>

                    {

                        FollowStopCondition[] conditions = count == 6

                            ? FollowStopCondition.Parse(values[5], coordinateGoal: true) : Array.Empty<FollowStopCondition>();

                        return new InjectionValue(bridge is IApiCoordinateFollowBridge follow

                            ? follow.FollowPoint(NumberConversions.ToInt(values[0]), NumberConversions.ToInt(values[1]),

                                NumberConversions.ToInt(values[2]), NumberConversions.ToInt(values[3]), ToBoolean(values[4]), conditions) : 0);

                    }

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

int UO.GetDir();
int UO.GetDir(object? id);

Liest die Zeichenrichtung aus dem Clientmodell.

• id – Optionales Objekt nur in den angegebenen Einzelparameterformen: serial Zahl/Hex-Zeichenfolge, „self“, „lasttarget“ oder Name AddObject. Dies ist nicht graphic/type. Ohne Argumente wird der eigene Charakter gelesen. Bevor Sie ein anderes Objekt lesen, überprüfen Sie UO.Exists; Ein unbekannter Name öffnet den Bereich nicht.

int — Richtung mobile ohne Laufbit: 0=N, 1=NE, 2=E, 3=SE, 4=S, 5=SW, 6=W, 7=NW. Für unbekannt gibt mobile 0 zurück, was ebenfalls Norden bedeutet.

• Bereits empfangene lokale Daten werden gelesen. Die Anfrage öffnet den Status nicht und zwingt den Server nicht, ein Update zu senden. Nach einem Tod, einem Kartenübergang oder einer Objektlöschung können sich die Werte zwischen zwei Aufrufen ändern.
• C# unterscheidet Groß- und Kleinschreibung. Verwenden Sie den genauen UO-Namen. Numerische Flags mit 0 vergleichen; bool nur bei Rückgabetyp bool verwenden.

Jedes Beispiel kann als separate Datei .csx gespeichert und in IDE ausgeführt werden. Die UO-Objekt- und Wartefunktionen stellen den Host der aktuellen Spielsitzung bereit. Ersetzen Sie Demo-serial-Namen, Koordinaten und Adressen durch Ihre eigenen.

Führe diesen Code als eigene .csx-Datei aus. Die Argumente stehen direkt im Aufruf; ersetze Beispielnamen, Serials und Adressen durch eigene Werte.

Das Ergebnis eines Aufrufs wird im Journal ausgegeben. Zahlen werden nicht in bool umgewandelt; bei Arrays wird die Anzahl der Elemente angezeigt.

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

Parameter und Ablauf:

• Der Aufruf ohne Argumente bezieht sich auf self. Die Richtung des Zeichens wird im Wert gespeichert.
• Convert.ToString wandelt die auszugebende Zahl um und ändert die Bedeutung des Ergebnisses nicht.

var value = UO.GetDir();
UO.Print("GetDir: " + Convert.ToString(value));

Parameter und Ablauf:

• Der Wert wird einmal ohne Argumente gelesen. Die Richtung des Zeichens wird in der angezeigten Berechnung oder Bedingung verwendet.
• Numerische Schwellenwerte sind Beispiele für Skriptbedingungen und keine neuen Client-Grenzwerte. Das Feld speichert die oben beschriebenen Servereinheiten und Einschränkungen.

return  RunScenario();
 object? RunScenario()
{
    var value = UO.GetDir();
    if (Truth(value == 2))
    {
        UO.Print("Facing east");
    }

    return null;
}

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