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

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

Koordinaten, Entfernungen, Sichtlinie, Geländegängigkeit und Kartendaten. Das Abrufen einer Route wird separat in Bewegung beschrieben.

UO.X · UO.Y · UO.Z · UO.GetX · UO.GetY · UO.GetZ

UO.Dist · UO.GetDistance

UO.CheckLOS · UO.LOSOptions

UO.WorldNum · UO.GetWorldNum

UO.GetWorldCell · UO.GetMapCell · UO.IsWorldCellPassable · UO.GetSurfaceZ · UO.GetNextStepZ · UO.GetWorldTilesArray

UO.GetLandscapeTile · UO.GetLandTileAt · UO.GetLandTileData · UO.GetLandTilesArray · UO.GetLandTilesArrayEx

UO.GetStaticArt · UO.GetStaticTileAt · UO.GetStaticTileData · UO.GetStaticTiles · UO.GetStaticTilesArray · UO.GetStaticTilesArrayEx · UO.ReadStaticsXY · UO.PrivateGetTile · UO.GetTileXYM · UO.GetLayerCount

UO.GetTileFlags · UO.GetTileHeight · UO.GetTileLayer · UO.GetTileName · UO.IsWaterTile · UO.IsTreeTile · UO.IsMineTile · UO.ConvertIntegerToFlags

UO.AddUserStatic · UO.ClearUserStatics · UO.GetUserStatic · UO.GetUserStatics · UO.RemoveUserStatic · UO.UserStaticExists

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 target = UO.GetSerial("lasttarget");
if (Truth(UO.Exists(target)))
{
    var distance = UO.GetDistance(target);
    if (Truth(distance <= 2))
    {
        UO.Print("Target is within two tiles");
    }
}

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 result = UO.IsWorldCellPassable(x,y,z,x+1,y,z,UO.WorldNum());
if (Truth(Truth(result[0]) == true))
{
    UO.Print("Passable, Z=" + Convert.ToString(result[1]));
}
else
{
    UO.Print("Blocked");
}

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 · 繁體中文 · 日本語 · 한국어

dynamic UO.AddUserStatic(object? staticItem, object? worldNum);
int UO.AddUserStatic(object? graphic, object? x, object? y, object? z, object? hue, object? map);

Fügt einen benutzerdefinierten statischen Eintrag zum lokalen Skriptstatus hinzu. Numerisch graphic wird für die lokale Hindernisprüfung durch den Pathfinder verwendet; Das Objekt wird nicht auf dem Server erstellt. Ein Aufruf mit zwei Argumenten und nicht nummeriertem Text behält alte Werte bei und fügt dem Pathfinder keine statische Aufladung hinzu.

• staticItem – numerischer graphic oder alter Textwert.
• worldNum – Index der Karte für die Aufzeichnung oder lokale Statik.
• graphic - ID Statik von 0 bis 65535.
• z – Höhe. Beim Hinzufügen zum Pathfinder ist der Wert auf den mit byte gekennzeichneten Bereich begrenzt.
• hue - hue; wenn hinzugefügt, begrenzt auf den Bereich von 0 bis 65535.
• map – Kartenindex; Für die Managerverarbeitung ist der Bereich auf 0–255 begrenzt.
• x – Benutzerdefinierte Statistiken für World X; int. Der Manager akzeptiert Koordinaten innerhalb der aktuell geladenen Karte.
• y – Benutzerdefinierte Statistiken für World Y; int. Der Manager akzeptiert Koordinaten innerhalb der aktuell geladenen Karte.

Positives ID des erstellten Eintrags. Für die Sechs-Parameter-Form führen negative graphic, x, y oder map sowie graphic über 65535 zu -1. ID kann an UO.UserStaticExists, UO.RemoveUserStatic übergeben oder zum Überprüfen/Löschen eines Legacy-Datensatzes verwendet werden. Das zurückgegebene ID allein bestätigt nicht, dass die statische Aufladung sichtbar ist oder auf dem Server angewendet wird.

• • UO.AddUserStatic('tree', 0) – da tree keine Zahl ist, speichert ein Paar Originalwerte als Legacy-Datensatz im Laufzeitstatus; Pathfinder verwendet es nicht.
• Ein Zwei-Parameter-Aufruf mit dem numerischen graphic fügt die Statik dieses graphic zu den aktuellen Koordinaten des Zeichens hinzu, wobei z und hue des Zeichens 0 sind.
• Der Sechs-Parameter-Aufruf fügt eine Statik mit dem angegebenen graphic, den Koordinaten, der Höhe, hue und der Karte hinzu. Pathfinding berücksichtigt dies nur auf der aktiven Karte und gemäß den graphic-Flags in den Client-Kacheldaten.

Diese Einträge sind lokal für den Skript-Client: Sie erstellen kein Spielobjekt, stellen keine Netzwerkanfrage und ändern keine Shard-Daten.

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.

object? result = UO.AddUserStatic(0x0CCA, UO.GetWorldNum());
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

Parameter und Ablauf:

• Speichern Sie das Paar als Legacy-Daten. Text StaticItem stellt kein Hindernis für den Pfadfinder dar.

var legacyId = UO.AddUserStatic("tree", 0);
UO.Print(Convert.ToString(legacyId));

Parameter und Ablauf:

• Der numerische Wert graphic wird zur Position des Zeichens auf der aktuellen Karte hinzugefügt.

return  RunScenario();
 object? RunScenario()
{
    var staticId = UO.AddUserStatic(0x0CCA, UO.GetWorldNum());
    UO.Print(Convert.ToString(staticId));
    return null;
}

Parameter und Ablauf:

• Fügen Sie der angegebenen Position und der angegebenen Karte explizit lokales statisches graphic 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()
    {
        var staticId = UO.AddUserStatic(0x0CCA, UO.GetX(), UO.GetY(), UO.GetZ(), 0, UO.GetWorldNum());
        UO.Print(Convert.ToString(staticId));
        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: staticItem (Any), worldNum (Any)

Ergebnis: dynamic / Any.

Beim Aufruf:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(1, bridge.WorldNumber).
• InjectionScript.Runtime.NumberConversions.TryStr2Int: NumberConversions.TryStr2Int(arguments[0].String, out graphic).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Text: Text(0).
• InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(arguments[0]).
• InjectionScript.Runtime.InjectionApiUO.AddUserStatic: AddUserStatic(graphic, bridge.GetX(bridge.Self), bridge.GetY(bridge.Self), bridge.GetZ(bridge.Self), 0, map).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetX: bridge.GetX(bridge.Self).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetY: bridge.GetY(bridge.Self).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetZ: bridge.GetZ(bridge.Self).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.WorldNumber: bridge.WorldNumber.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self: bridge.Self.

Interner Implementierungscode; kein eigenständiges Skript.

case "adduserstatic":

                {

                    int map = Arg(1, bridge.WorldNumber);

                    if (arguments[0].Kind != InjectionValueKind.Array)

                    {

                        int graphic = 0;

                        if (arguments[0].Kind == InjectionValueKind.String &&

                            !NumberConversions.TryStr2Int(arguments[0].String, out graphic))

                        {

                            int legacyId = state.NextUserStaticId++;

                            state.UserStatics[legacyId] = Text(0) + "|" + Text(1);

                            return new InjectionValue(legacyId);

                        }

                        graphic = arguments[0].Kind == InjectionValueKind.String

                            ? graphic

                            : NumberConversions.ToInt(arguments[0]);

                        return new InjectionValue(AddUserStatic(graphic, bridge.GetX(bridge.Self), bridge.GetY(bridge.Self),

                            bridge.GetZ(bridge.Self), 0, map));

                    }

                    if (arguments[0].Array.Length < 4)

                        throw new NativeSubrutineException("AddUserStatic expects [graphic,x,y,z,color] and world number, or graphic,x,y,z,color,world.");

                    InjectionValue[] item = arguments[0].Array;

                    return new InjectionValue(AddUserStatic(

                        NumberConversions.ToInt(item[0]), NumberConversions.ToInt(item[1]), NumberConversions.ToInt(item[2]),

                        NumberConversions.ToInt(item[3]), item.Length > 4 ? NumberConversions.ToInt(item[4]) : 0, map));

                }

Parameter: graphic (Any), x (Any), y (Any), z (Any), hue (Any), map (Any)

Ergebnis: int / Integer.

Beim Aufruf:

• InjectionScript.Runtime.InjectionApiUO.Register [AddUserStatic].
• InjectionScript.Runtime.InjectionApiUO.AddUserStatic: AddUserStatic( NumberConversions.ToInt(values[0]), NumberConversions.ToInt(values[1]), NumberConversions.ToInt(values[2]), NumberConversions.ToInt(values[3]), NumberConversions.ToInt(values[4]), NumberConversions.ToInt(values[5])).
• InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(values[0]).

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(AddUserStatic(

                    NumberConversions.ToInt(values[0]), NumberConversions.ToInt(values[1]), NumberConversions.ToInt(values[2]),

                    NumberConversions.ToInt(values[3]), NumberConversions.ToInt(values[4]), NumberConversions.ToInt(values[5])))

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

dynamic UO.CheckLOS(object? xfrom, object? yfrom, object? zfrom, object? xto, object? yto, object? zto, object? worldNum);

Überprüft die lokale Passierbarkeit einer Linie zwischen zwei Kartenpunkten über CheckPortableLineOfSight.

• xfrom – Quelle X: 0..65535.
• yfrom – Quelle Y: 0..65535.
• zfrom – Anfangs-Z, int.
• xto - Ende X: 0..65535.
• yto - Ende Y: 0..65535.
• zto – Finales Z, int.
• worldNum — 0..255. Ein Balken mit einer Länge ungleich Null liest nur die aktuell geladene _world.Map/World.Map: via CheckWorldStep benötigt WorldNum == _world.MapIndex und Live Player.Pathfinder. Eine andere Facette ist nicht geladen oder angefordert; Es gibt keine Karte/Charakter/Pfadfinder oder der Schritt ist nicht verfügbar - 0. Durch das Ausschließen von identischem X/Y wird der gesamte Zellzyklus übersprungen: mit X/Y in 0..65535, WorldNum V 0..255 und abs(Zvon-Zto)<=20 kehrt zurück 1 auch ohne geladene Karte oder mit einer anderen Kartennummer. Dies ist kein Beweis für die Geometrie oder Erreichbarkeit. Das Ergebnis ist lokal, keine Lösung LOS Server.

int 1 – der lokale Strahl hat X/Y erreicht und die endgültige Höhe weicht von Zto um nicht mehr als 20 ab; 0 – ungültige Koordinaten, Hindernisse oder Prüfgrenze.

• Der Strahl bewegt sich nach dem Bresenham-Algorithmus mit maximal 4096 Schritten. In jeder Zelle werden BadLocations, CheckWorldStep und die zurückgegebene Höhe berücksichtigt.
• Bei LosOptions != 0 wird zusätzlich CheckLosCell verwendet; Bit 0x100 prüft beide Seitenquadrate der Diagonale. Die lokale Geometrieprüfung validiert keine serverspezifischen LOS-Regeln und verschiebt nichts.
• Minor byte (Wert & 0xFF) wählt Algorithmus 1..4; andere Werte des Moll-byte in CheckLosCell verwenden den 3-Algorithmus. Die Algorithmen 1/2 blockieren Mauer und unpassierbar, 3 zusätzlich NoShoot und 4 aktiviert NoShoot nur mit 0x200 und erlaubt Fensterhindernisse nur mit 0x400. Bit 0x100 überprüft zusätzlich beide Seitenzellen jedes diagonalen Strahlschritts für jeden ausgewählten Algorithmus. value=0 deaktiviert die zusätzlichen CheckLosCell/Diagonalprüfungen, BadLocations und CheckWorldStep bleiben jedoch bestehen. Zum Beispiel wählt 4+0x100+0x200+0x400 Benutzerdefiniert mit drei Flags aus; Setter behält den ursprünglichen int bei, nicht den normalisierten Algorithmus.
• Ein Balken mit einer Länge ungleich Null liest nur die aktuell geladene _world.Map/World.Map: via CheckWorldStep benötigt WorldNum == _world.MapIndex und Live Player.Pathfinder. Eine andere Facette ist nicht geladen oder angefordert; Es gibt keine Karte/Charakter/Pfadfinder oder der Schritt ist nicht verfügbar - 0. Durch das Ausschließen von identischem X/Y wird der gesamte Zellzyklus übersprungen: mit X/Y in 0..65535, WorldNum V 0..255 und abs(Zvon-Zto)<=20 kehrt zurück 1 auch ohne geladene Karte oder mit einer anderen Kartennummer. Dies ist kein Beweis für die Geometrie oder Erreichbarkeit. Das Ergebnis ist lokal, keine Lösung LOS Server.
• CheckLosCell umgeht das geladene Land/Static/Multi/Item einer Zelle. Unpassierbare Landblöcke mit abs(rayZ-land.Z)<=20. Die Static/Multi/Item-Flags sind nur im Bereich Tile.Z-2 . gültig. Tile.Z+max(1,Height)+2; Das zulässige benutzerdefinierte Fenster wird übersprungen, bis „Wand/Unpassierbar/NoShoot“ aktiviert ist. X/Y-Strahl verwendet Bresenham, maximale 4096 Schritte; Z wird von Flächen CheckWorldStep genommen, nicht auf Zto interpoliert, die endgültige Höhentoleranz beträgt 20.

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.

object? result = UO.CheckLOS(UO.X(), UO.Y(), UO.Z(), UO.X() + 1, UO.Y(), UO.Z(), UO.WorldNum());
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

Parameter und Ablauf:

• Identische Punkte verlaufen innerhalb akzeptabler X/Y/Karte.

var x = UO.GetX();
var y = UO.GetY();
var z = UO.GetZ();
var visible = UO.CheckLOS(x,y,z,x,y,z,UO.WorldNum());
UO.Print(Convert.ToString(visible));

Parameter und Ablauf:

• Die Höhe und Durchlässigkeit der Nachbarzelle werden aus der lokalen Karte abgelesen.

return  RunScenario();
 object? RunScenario()
{
    var x = UO.GetX();
    var y = UO.GetY();
    var z = UO.GetZ();
    var clear = UO.CheckLOS(x, y, z, x + 1, y, z, UO.WorldNum());
    UO.Print(Convert.ToString(clear));
    return null;
}

Parameter und Ablauf:

• Ein negatives X wird mit dem Ergebnis 0 abgelehnt, ohne die Karte zu durchlaufen.

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 clear = UO.CheckLOS(-1, 0, 0, 0, 0, 0, 0);
        UO.Print(Convert.ToString(clear));
        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: xfrom (Any), yfrom (Any), zfrom (Any), xto (Any), yto (Any), zto (Any), worldNum (Any)

Ergebnis: dynamic / Any.

Beim Aufruf:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• InjectionScript.Runtime.InjectionApiUO.CheckPortableLineOfSight: CheckPortableLineOfSight(Arg(0), Arg(1), Arg(2), Arg(3), Arg(4), Arg(5), Arg(6)).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).

Interner Implementierungscode; kein eigenständiges Skript.

case "checklos": return new InjectionValue(CheckPortableLineOfSight(Arg(0), Arg(1), Arg(2), Arg(3), Arg(4), Arg(5), Arg(6)) ? 1 : 0);

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

void UO.ClearUserStatics();

Entfernt alle statischen Benutzerlaufzeiteinträge und lokalen statischen Managerobjekte.

Es gibt keine Parameter.

void – kein Rückgabewert.

• State.UserStatics und Managerobjekte werden gelöscht. Hochgeladene Kartendateien und echte Serverelemente werden 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.

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

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

Parameter und Ablauf:

• Entfernt alle statischen Benutzerlaufzeiteinträge und lokalen statischen Managerobjekte.

UO.ClearUserStatics();

Parameter und Ablauf:

• Fügen Sie der aktuellen Zelle eine lokale Statik hinzu und entfernen Sie dann alle benutzerdefinierten Statiken.

return  RunScenario();
 object? RunScenario()
{
    var localStatic = UO.AddUserStatic(0x0CCA, UO.GetX(), UO.GetY(), UO.GetZ(), 0, UO.WorldNum());
    UO.ClearUserStatics();
    return null;
}

Parameter und Ablauf:

• Das Löschen eines leeren Satzes ist akzeptabel und erstellt keine neue Einstellung.

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.ClearUserStatics();
        UO.ClearUserStatics();
        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.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.ClearUserStatics: bridge.ClearUserStatics().

Interner Implementierungscode; kein eigenständiges Skript.

case "clearuserstatics": state.UserStatics.Clear(); bridge.ClearUserStatics(); return InjectionValue.Unit;

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

dynamic UO.ConvertIntegerToFlags(object? group, object? value);

Analysiert eine numerische Maske von Kachelflags in ein Array von Aufzählungsnamen TileFlag.

• group – int: nur 1 oder 2 ermöglichen die Konvertierung; Jeder andere Wert führt zu einem leeren Array.
• value – Eine Maske, die Arg in ein vorzeichenbehaftetes 32-Bit int umwandelt, dann führt die Brücke zu ulong. Für Flags mit hohem 64-Bit behält diese Form nicht die vollständige Maske bei.

Array von Zeichenfolgen mit dem Namen ungleich Null TileFlag, deren Bits vollständig in der Maske vorhanden sind. Die Maske 0 erzeugt ein leeres Array.

• Die Gruppen 1 und 2 verwenden dieselbe Enum.GetValues und nicht unterschiedliche Verzeichnisse. Dies ist eine lokale Maskentransformation; Kacheldaten werden nicht angefordert.
• Die API-Registrierung verwendet object?, aber der Arg(1)-Dispatcher sendet int. Das negative int-Zeichen wird erweitert, wenn es in ulong umgewandelt wird. GetTileFlags gibt außerdem nur die niedrigen 32-Bits mit Vorzeichen zurück. int: Dieses kompatible Paar stellt nicht den vollständigen 64-Bit-Kacheldatenvertrag bereit.

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.

object? result = UO.ConvertIntegerToFlags(1, 0);
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

Parameter und Ablauf:

• In der Maske 0 ist kein Flag ungleich Null vorhanden.

var flags = UO.ConvertIntegerToFlags(1,0);
UO.Print(Convert.ToString(ArrayLength(flags)));

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;

Parameter und Ablauf:

• Das Array enthält die echten Namen TileFlag der ausgewählten Maske.

return  RunScenario();
 object? RunScenario()
{
    var flags = UO.ConvertIntegerToFlags(2, 1);
    for (int i = (int)(0); i <= ArrayLength(flags) - 1; i += (int)(1))
    {
        UO.Print(flags[i]);
    }

    return null;
}

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;

Parameter und Ablauf:

• Gruppe 0 wird von diesem Befehl nicht akzeptiert und gibt ein leeres Array zurück.

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

     public object? RunScenario()
    {
        var flags = UO.ConvertIntegerToFlags(0, 1);
        UO.Print(Convert.ToString(ArrayLength(flags)));
        return null;
    }

    int ArrayLength(object? value) => value is System.Array array ? array.Length : 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: group (Any), value (Any)

Ergebnis: dynamic / Any.

Beim Aufruf:

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

Interner Implementierungscode; kein eigenständiges Skript.

case "convertintegertoflags":

                    return new InjectionValue(bridge.ConvertTileFlags(Arg(0), Arg(1))

                        .Select(flag => new InjectionValue(flag)).ToArray());

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

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

Berechnet den Abstand in Zellen zwischen zwei Weltpunkten: der größte der absoluten Unterschiede zwischen X und Y.

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

int – Abstand in Zellen, nicht negativ für gültige Koordinaten. 0 bedeutet dasselbe XY, 1 – eine Zelle. Dies ist eine Menge, kein Zeichen für Erfolg. Ein separater Vergleichsabstand <= 2 gibt bool true oder false zurück; der Abstand selbst bleibt int.

• 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.
• Formel: Max(Abs(Xto-Xfrom), Abs(Yto-Yfrom)). Wenn Sie die Punkte neu anordnen, ist das Ergebnis dasselbe. Dabei handelt es sich nicht um die euklidische Distanz, nicht um die Summe der Differenzen und nicht um die Anzahl der Schritte beim Umgehen eines Hindernisses.

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

Parameter und Ablauf:

• Von (100,100) bis (103,104): Die absoluten Unterschiede betragen 3 und 4, mit einem Maximum von 4. Main gibt int 4 zurück.
• int – Abstand in Zellen, nicht negativ für gültige Koordinaten. 0 bedeutet dasselbe XY, 1 – eine Zelle. Dies ist eine Menge, kein Zeichen für Erfolg. Ein separater Vergleichsabstand <= 2 gibt bool true oder false zurück; der Abstand selbst bleibt int.
• Formel: Max(Abs(Xto-Xfrom), Abs(Yto-Yfrom)). Wenn Sie die Punkte neu anordnen, ist das Ergebnis dasselbe. Dabei handelt es sich nicht um die euklidische Distanz, nicht um die Summe der Differenzen und nicht um die Anzahl der Schritte beim Umgehen eines Hindernisses.

return UO.Dist(100,100,103,104);

Parameter und Ablauf:

• Von (100,100) bis (101,99) beträgt der Abstand 1. Ein separater Vergleich der Distanz<=2 ergibt true=1. Main gibt „1:1“ zurück: Die erste Einheit ist die Distanz, die zweite das logische Ergebnis des Vergleichs.
• int – Abstand in Zellen, nicht negativ für gültige Koordinaten. 0 bedeutet dasselbe XY, 1 – eine Zelle. Dies ist eine Menge, kein Zeichen für Erfolg. Ein separater Vergleichsabstand <= 2 gibt bool true oder false zurück; der Abstand selbst bleibt int.
• Formel: Max(Abs(Xto-Xfrom), Abs(Yto-Yfrom)). Wenn Sie die Punkte neu anordnen, ist das Ergebnis dasselbe. Dabei handelt es sich nicht um die euklidische Distanz, nicht um die Summe der Differenzen und nicht um die Anzahl der Schritte beim Umgehen eines Hindernisses.

return  RunScenario();
 object? RunScenario()
{
    var distance = UO.Dist(100, 100, 101, 99);
    var close = distance <= 2;
    return Convert.ToString(distance) + ":" + Convert.ToString(close);
    return null;
}

Parameter und Ablauf:

• UO.Dist gibt 4 zurück. RebuildTileDistance berechnet die Differenzen über Abs, vergleicht sie und gibt den größeren zurück, ebenso 4. Main gibt „4:4“ zurück. Der Assistent wird im Beispiel vollständig dargestellt und ist kein weiterer Motorbefehl.
• int – Abstand in Zellen, nicht negativ für gültige Koordinaten. 0 bedeutet dasselbe XY, 1 – eine Zelle. Dies ist eine Menge, kein Zeichen für Erfolg. Ein separater Vergleichsabstand <= 2 gibt bool true oder false zurück; der Abstand selbst bleibt int.
• Formel: Max(Abs(Xto-Xfrom), Abs(Yto-Yfrom)). Wenn Sie die Punkte neu anordnen, ist das Ergebnis dasselbe. Dabei handelt es sich nicht um die euklidische Distanz, nicht um die Summe der Differenzen und nicht um die Anzahl der Schritte beim Umgehen eines Hindernisses.

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.Dist(100, 100, 103, 104);
        var rebuilt = RebuildTileDistance(100, 100, 103, 104);
        return Convert.ToString(actual) + ":" + Convert.ToString(rebuilt);
        return null;
    }

    dynamic RebuildTileDistance(dynamic Xfrom, dynamic Yfrom, dynamic Xto, dynamic Yto)
    {
        var dx = Math.Abs(Xto - Xfrom);
        var dy = Math.Abs(Yto - Yfrom);
        if (Truth(dx > dy))
        {
            return dx;
        }

        return dy;
    }

    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.GetDistance: GetDistance(Arg(0), Arg(1), Arg(2), Arg(3)).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetDistance: bridge.GetDistance(Arg(0)).

Interner Implementierungscode; kein eigenständiges Skript.

case "dist": return new InjectionValue(arguments.Length >= 4

                    ? GetDistance(Arg(0), Arg(1), Arg(2), Arg(3))

                    : bridge.GetDistance(Arg(0)));

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

int UO.GetDistance(object? id);
int UO.GetDistance(object? x, object? y);
int UO.GetDistance(object? id1, object? x2, object? y2);
int UO.GetDistance(object? x1, object? y1, object? x2, object? y2);

Misst den Abstand in Zellen basierend auf den maximalen X/Y-Unterschieden. Dies ist eine geometrische Schätzung ohne Wegfindung.

• id – Ein Argument: serial oder der Alias ​​des geladenen Objekts, die Entfernung, die Sie erreichen möchten.
• x – Zwei Argumente: Weltziel. Der Anfang ist GetX(self), GetY(self).
• y – Zwei Argumente: Weltziel. Der Anfang ist GetX(self), GetY(self).
• id1 – In Form mit drei Argumenten – serial/Alias ​​des Objekts, dessen Koordinaten als Ursprung dienen.
• x1 – In Form von vier Argumenten die Koordinaten des Ursprungs. Für dieses Formular wird kein Objekt benötigt.
• y1 – In Form von vier Argumenten die Koordinaten des Ursprungs. Für dieses Formular wird kein Objekt benötigt.
• x2 – In Formularen mit drei/vier Argumenten die Endkoordinaten. Verwechseln Sie sie nicht mit serial des zweiten Objekts.
• y2 – In Formularen mit drei/vier Argumenten die Endkoordinaten. Verwechseln Sie sie nicht mit serial des zweiten Objekts.

int - max(abs(x2-x1), abs(y2-y1)): Horizontal, vertikal und diagonal zu einer benachbarten Zelle haben einen Abstand 1. Höhe Z und Hindernisse werden nicht berücksichtigt. Für das unbekannte serial gibt die Ein-Argument-Form 0 zurück; für ein vorhandenes Objekt ohne Zeichen - 65535. Für die unbekannte ID1 verwendet das Formular mit drei Argumenten (0,0). Überprüfen Sie daher zuerst Exists(id1).

• Die Einzelobjektform verwendet das aktuelle World.RangeSize-Bereichszentrum und die letzte Position in der Schrittwarteschlange des sich bewegenden Mobs. Während der Bewegung kann das Ergebnis von der Berechnung über GetX/GetY abweichen.
• Koordinatenformulare funktionieren mit übergebenen Zahlen. Verwenden Sie für Spielkoordinaten den Bereich 0..65535; Extremwerte von int und Differenzüberlauf sind keine unterstützten Koordinaten.
• Das Team verspricht nicht, dass das Ziel erreichbar sein wird. Zum Bewegen benötigen Sie MoveXY/NewMoveXY und die Überprüfung des Ergebnisses; Wände können den eigentlichen Weg verlängern.

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

Parameter und Ablauf:

• Ziel ist serial, nicht type. Die Exists-Prüfung verhindert, dass der Nullpunkt eines unbekannten Objekts mit einem nahen Ziel verwechselt wird.
• distance<=2 prüft den X/Y-Abstand. Sichtbarkeit und Passierbarkeit werden separat geprüft.

var target = UO.GetSerial("lasttarget");
if (Truth(UO.Exists(target)))
{
    var distance = UO.GetDistance(target);
    if (Truth(distance <= 2))
    {
        UO.Print("Target is within two tiles");
    }
}

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:

• x1=100, y1=200, x2=103, y2=204. Die Unterschiede sind 3 und 4.
• Das Ergebnis ist 4, nicht 7 und nicht das euklidische 5.

return  RunScenario();
 object? RunScenario()
{
    var distance = UO.GetDistance(100, 200, 103, 204);
    UO.Print(Convert.ToString(distance));
    return null;
}

Parameter und Ablauf:

• Die beiden x/y-Argumente verwenden die aktuelle Position von self. Mit den drei Argumenten id1/x2/y2 können Sie das Startobjekt explizit angeben.
• Bei konstanter Position sind beide Größen gleich 3. Die Koordinaten müssen innerhalb der Grenzen der Karte bleiben.

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

     public object? RunScenario()
    {
        var x = UO.GetX() + 3;
        var y = UO.GetY() + 1;
        var fromSelf = UO.GetDistance(x, y);
        var fromObject = UO.GetDistance("self", x, y);
        UO.Print(Convert.ToString(fromSelf) + " / " + Convert.ToString(fromObject));
        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: id (Any/Integer/String)

Ergebnis: int / Any.

Beim Aufruf:

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

Interner Implementierungscode; kein eigenständiges Skript.

case "getdistance": return new InjectionValue(bridge.GetDistance(Arg(0)));

Parameter: id (Any/Integer/String)

Ergebnis: int / Integer.

Beim Aufruf:

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

Interner Implementierungscode; kein eigenständiges Skript.

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

Parameter: id (Any/Integer/String)

Ergebnis: int / Integer.

Beim Aufruf:

• InjectionScript.Runtime.InjectionApiUO.GetDistance.
• InjectionScript.Runtime.InjectionApiUO.GetDistance: GetDistance(GetObject(id)).
• InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(id).

Interner Implementierungscode; kein eigenständiges Skript.

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

Parameter: x (Integer), y (Integer)

Ergebnis: int / Integer.

Beim Aufruf:

• InjectionScript.Runtime.InjectionApiUO.GetDistance.
• InjectionScript.Runtime.InjectionApiUO.GetDistance: GetDistance(bridge.GetX(bridge.Self), bridge.GetY(bridge.Self), x, y).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetX: bridge.GetX(bridge.Self).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetY: bridge.GetY(bridge.Self).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.Self: bridge.Self.

Interner Implementierungscode; kein eigenständiges Skript.

public int GetDistance(int x, int y) => GetDistance(bridge.GetX(bridge.Self), bridge.GetY(bridge.Self), x, y);

Parameter: id1 (Any), x2 (Any), y2 (Any)

Ergebnis: int / Integer.

Beim Aufruf:

• InjectionScript.Runtime.InjectionApiUO.GetDistance.
• InjectionScript.Runtime.InjectionApiUO.GetObject: GetObject(id1).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetX: bridge.GetX(obj1).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetY: bridge.GetY(obj1).
• InjectionScript.Runtime.InjectionApiUO.GetDistance: GetDistance(x1, y1, NumberConversions.ToInt(x2), NumberConversions.ToInt(y2)).
• InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(x2).

Interner Implementierungscode; kein eigenständiges Skript.

public int GetDistance(InjectionValue id1, InjectionValue x2, InjectionValue y2)

        {

            var obj1 = GetObject(id1);

            int x1 = bridge.GetX(obj1);

            int y1 = bridge.GetY(obj1);



            return GetDistance(x1, y1, NumberConversions.ToInt(x2), NumberConversions.ToInt(y2));

        }

Parameter: x1 (Integer), y1 (Integer), x2 (Integer), y2 (Integer)

Ergebnis: int / Integer.

Beim Aufruf:

• InjectionScript.Runtime.InjectionApiUO.GetDistance.

Interner Implementierungscode; kein eigenständiges Skript.

public int GetDistance(int x1, int y1, int x2, int y2)

        {

            int dx = Math.Abs(x1 - x2);

            int dy = Math.Abs(y1 - y2);



            return Math.Max(dx, dy);

        }

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

dynamic UO.GetLandTileAt(object? x, object? y);
dynamic UO.GetLandTileAt(object? x, object? y, object? map);

Gibt den erweiterten Grundbucheintrag der ausgewählten Zelle zurück.

• x – X-Zelle der aktuell geladenen Karte; Weltkoordinate, nicht Position innerhalb des Gumps.
• y – Y-Zelle der aktuell geladenen Karte; Weltkoordinate, nicht Position innerhalb des Gumps.
• map – Kartennummer. Wenn dieses Argument im ausgewählten Formular nicht vorhanden ist, wird die aktuelle Karte verwendet. Der echte Client liest nur Kacheln aus der aktuell geladenen Karte.

Array von 11-Feldern eines Datensatzes; Indizes beginnen mit 0:

• [0] kind — string: „land“, „static“ oder „object“.
• [1] serial - int: serial dynamisches Element; für Land/statisch ist 0.
• [2] graphic - int: type Grafiken.
• [3] x, [4] y - int: Weltkoordinaten der Zelle.
• [5] z - int: die Höhe der Basis in der Welt.
• [6] hue - int: Farbe, in Bodennähe 0.
• [7] flags – int: niedrige 32 Bits der Tiledata-Flags.
• [8] name - string: Name aus Kacheldaten.
• [9] layer - int: Ausrüstungsschicht aus Tiledata, in Bodennähe 0; kein statischer Index.
• [10] height - int: Höhe graphic aus Kacheldaten, bodennah 0; nicht die Koordinate Z.

Ein leeres Array [] bedeutet keinen Eintrag oder eine unzugängliche Karte/Zelle. Für GetStaticTileAt erzeugt ein negativer/zu großer Index auch []; Der Indexüberlauf wählt nicht den Eintrag einer anderen Person aus.

• Die Daten beziehen sich auf die aktuell geladene Karte. Eine weitere Karte oder nicht erreichbare Zelle führt zu einem leeren Array. Bei direkten Kachelabfragen können zusätzlich Karteninkongruenzen gemeldet werden. GetWorldCell und GetWorldTilesArray geben sofort ein leeres Array ohne eine solche Meldung zurück.
• Array-Indizes beginnen mit 0. Überprüfen Sie ArrayLength, bevor Sie das Feld lesen. Z steht für Welthöhe; Layer ist die Geräteeigenschaft aus Tiledata und Index ist die Seriennummer des Zelleneintrags.

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.

object? result = UO.GetLandTileAt(UO.GetX(), UO.GetY());
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

Parameter und Ablauf:

• x/y – Zeichenposition; Die Karte wird automatisch abgesenkt und ausgewählt. Für GetStaticTileAt bedeutet index=0 den ersten Eintrag.
• Die Felder [2], [5], [9] haben unterschiedliche Bedeutungen; Alle sind schreibgeschützt, nachdem die Länge von 11 überprüft wurde.

var tile = UO.GetLandTileAt(UO.GetX(), UO.GetY());
if (Truth(ArrayLength(tile) == 11))
{
    UO.Print("Type: " + Convert.ToString(tile[2]));
    UO.Print("World Z: " + Convert.ToString(tile[5]));
    UO.Print("Equipment layer: " + Convert.ToString(tile[9]));
}
else
{
    UO.Print("Tile is unavailable");
}

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;

Parameter und Ablauf:

• Es werden die gleichen Koordinaten verwendet; GetStaticTileAt liest index=0.
• Tile[8] ist die Titelzeichenfolge, Tile[10] ist die Höhendimension aus Tiledata, nicht die Z-Basis.

return  RunScenario();
 object? RunScenario()
{
    var tile = UO.GetLandTileAt(UO.GetX(), UO.GetY());
    if (Truth(ArrayLength(tile) == 11))
    {
        UO.Print(tile[8]);
        UO.Print("Graphic height: " + Convert.ToString(tile[10]));
    }

    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;

Parameter und Ablauf:

• WaitTargetTile empfängt graphic, x, y, z aus den Feldern 2…5.
• Dies ist nur eine Vorbereitung für das nächste Ziel. Das Beispiel löst kein Werkzeug oder Zauber aus. serial=0 für Statik sollte nicht als ID des Elements übergeben werden.

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 tile = UO.GetLandTileAt(UO.GetX(), UO.GetY());
        if (Truth(ArrayLength(tile) == 11))
        {
            UO.WaitTargetTile(tile[2], tile[3], tile[4], tile[5]);
        }

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

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

Parameter: x (Any), y (Any)

Ergebnis: dynamic / Any.

Beim Aufruf:

• InjectionScript.Runtime.InjectionApiUO.GetLandTileAt.
• InjectionScript.Runtime.InjectionApiUO.GetLandTileAt: GetLandTileAt(x, y, new InjectionValue(bridge.WorldNumber)).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.WorldNumber: bridge.WorldNumber.

Interner Implementierungscode; kein eigenständiges Skript.

public InjectionValue GetLandTileAt(InjectionValue x, InjectionValue y)

            => GetLandTileAt(x, y, new InjectionValue(bridge.WorldNumber));

Parameter: x (Any), y (Any), map (Any)

Ergebnis: dynamic / Any.

Beim Aufruf:

• InjectionScript.Runtime.InjectionApiUO.GetLandTileAt.
• InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(x).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.GetLandscapeTile: bridge.GetLandscapeTile(cellX, cellY, world).
• InjectionScript.Runtime.InjectionApiUO.BuildWorldTileRecord: BuildWorldTileRecord("land", 0, land[0], cellX, cellY, land[1], 0, 0).

Interner Implementierungscode; kein eigenständiges Skript.

public InjectionValue GetLandTileAt(InjectionValue x, InjectionValue y, InjectionValue map)

        {

            int cellX = NumberConversions.ToInt(x);

            int cellY = NumberConversions.ToInt(y);

            int world = NumberConversions.ToInt(map);

            int[] land = bridge.GetLandscapeTile(cellX, cellY, world) ?? Array.Empty<int>();

            return land.Length >= 2

                ? BuildWorldTileRecord("land", 0, land[0], cellX, cellY, land[1], 0, 0)

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

        }

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

dynamic UO.GetLandTileData(object? tile);

Liest den erweiterten Landreferenzdatensatz aus Tiledata.

• tile ist ein Grafik-/type-Eintrag, nicht serial und kein Index innerhalb einer Zelle. Die Ländertabelle wird durch den Teamnamen selbst ausgewählt.

Array von 7-Feldern für gültiges graphic. Alle Felder int außer Name (string):

• [0] graphic — graphic/type Datensätze.
• [1] flags – niederwertige 32 Flag-Bits.
• [2] name – Name aus Kacheldaten (string).
• [3] texId - ID Bodentexturen.
• [4] wet — 1 bei Nasseinbau, sonst 0.
• [5] impassable — 1 wenn unpassierbar, sonst 0.
• [6] noDiagonal — 1 wenn noDiagonal, sonst 0.

Für ein ungültiges graphic gibt es keine Referenzeigenschaften: Es wird ein kurzes Array [переданный graphic, 0, ""] zurückgegeben. Überprüfen Sie die vollständige Länge, bevor Sie die Eigenschaften lesen. Dies ist kein Pascal-Datensatz oder eine Liste von Objekten.

• Der Befehl liest Kacheldaten und erfordert kein Element mit diesem graphic in der Welt. Flags beschreiben die Ressource; Das Ergebnis ersetzt keine vollständige Routenprüfung.

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.

object? result = UO.GetLandTileData(0x0003);
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

Parameter und Ablauf:

• Tile ist der numerische graphic der ausgewählten Tabelle.
• data[2] enthält den Namen. Die Längenprüfung trennt einen vollständigen Eintrag von einem kurzen Eintrag eines ungültigen graphic.

var data = UO.GetLandTileData(0x0003);
if (Truth(ArrayLength(data) == 7))
{
    UO.Print(data[2]);
}
else
{
    UO.Print("Tiledata entry is unavailable");
}

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;

Parameter und Ablauf:

• data[5] ist ein separates unpassierbares Feld: 1 (Bedingung erfüllt), 0 (Bedingung nicht erfüllt).
• Bei dieser Prüfung werden andere Objekte in der Zelle oder die Fähigkeiten des Charakters nicht berücksichtigt.

return  RunScenario();
 object? RunScenario()
{
    var data = UO.GetLandTileData(0x0003);
    if (Truth(ArrayLength(data) == 7))
    {
        if (Truth(data[5]))
        {
            UO.Print("Impassable flag is set");
        }
        else
        {
            UO.Print("Impassable flag is not set");
        }
    }

    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;

Parameter und Ablauf:

• data[0] wiederholt das übertragene graphic, data[1] ist eine allgemeine Flag-Maske.
• Die Maske kann mehrere Bits gleichzeitig enthalten; sein numerischer Wert ist nicht serial.

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

     public object? RunScenario()
    {
        var data = UO.GetLandTileData(0x0003);
        if (Truth(ArrayLength(data) == 7))
        {
            UO.Print("Graphic: " + Convert.ToString(data[0]));
            UO.Print("Flags: " + Convert.ToString(data[1]));
        }

        return null;
    }

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

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

Parameter: tile (Any)

Ergebnis: dynamic / Any.

Beim Aufruf:

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

Interner Implementierungscode; kein eigenständiges Skript.

case "getlandtiledata":

                    return BuildTileData(0, Arg(0));

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

dynamic UO.GetLandTilesArray(object? xmin, object? ymin, object? xmax, object? ymax, object? worldNum, object? tileType);

Sucht nach Landplättchen bei graphic/type in einem Rechteck.

• xmin – Weltkoordinaten von zwei Winkeln, einschließlich; 0..65535. Die neu angeordneten Winkel werden normalisiert. Fläche nicht größer als 1 000 000 Zellen; Ungültige Grenzen verursachen einen Skriptfehler, bevor die Karte gelesen wird.
• ymin – Weltkoordinaten von zwei Winkeln, einschließlich; 0..65535. Die neu angeordneten Winkel werden normalisiert. Fläche nicht größer als 1 000 000 Zellen; Ungültige Grenzen verursachen einen Skriptfehler, bevor die Karte gelesen wird.
• xmax – Weltkoordinaten von zwei Winkeln, einschließlich; 0..65535. Die neu angeordneten Winkel werden normalisiert. Fläche nicht größer als 1 000 000 Zellen; Ungültige Grenzen verursachen einen Skriptfehler, bevor die Karte gelesen wird.
• ymax – Weltkoordinaten von zwei Winkeln, einschließlich; 0..65535. Die neu angeordneten Winkel werden normalisiert. Fläche nicht größer als 1 000 000 Zellen; Ungültige Grenzen verursachen einen Skriptfehler, bevor die Karte gelesen wird.
• worldNum – Karte/Facette 0..255; Verwenden Sie UO.WorldNum(). Eine andere Karte ergibt ein leeres Array. Wenn sich die Karte zwischen den Blöcken ändert, wird das Teilergebnis verworfen.
• tileType – Eine graphic/type-Kachel, normalerweise 0..65535; das ist nicht serial. 0 ist das genaue graphic 0, -1 bedeutet kein type. Ein nicht übereinstimmendes type führt zu einem leeren Ergebnis.

Array von Einträgen [graphic, X, Y, Z]; alle Felder int. graphic – type der Erde, Z – ihr Fundament. Keine Übereinstimmungen: leeres Array. Die Menge ist ArrayLength(Ergebnis), nicht das Ergebnis selbst. Die Indizes beginnen mit 0. Dies ist kein bool-, serial- oder Pascal-Datensatz; Es gibt keinen siebten Ausgabeparameter.

• Lokale Daten werden gelesen. Die Suche ändert FindItem/FindCount nicht und führt keinen Verschiebungs-, Ziel- oder Netzwerkbefehl aus.
• Reihenfolge: X aufsteigend, innerhalb von X - Y aufsteigend. Aufzeichnungen einer Zelle bewahren die Reihenfolge der Brücke; Es ist nicht nach Entfernung oder Höhe sortiert.
• Die Suche wird in Blöcken von bis zu 32 Zellen mit einem Softbudget von etwa 1 ms verarbeitet. Die Stornierung wird zwischen den Portionen überprüft. Eine komplexe Zellen- oder Kaltablesung kann das Budget sprengen. Es ist besser, eine große Fläche zu unterteilen; Beim Lesen kann sich die Welt verändern.

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.

object? result = UO.GetLandTilesArray(UO.GetX(), UO.GetY(), UO.GetX() + 2, UO.GetY() + 2, UO.WorldNum(), 0x0003);
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

Parameter und Ablauf:

• x/y – Position self, Karte – aktuelle Karte. Die Region 3×3 umfasst die Grenzen. In Ex werden zwei type übertragen, in Normalform eines. Ändern Sie die Beispiele entsprechend Ihren Ressourcen. Dies ist ein graphic-Objekt, kein ID-Objekt.

var x = UO.GetX();
var y = UO.GetY();
var map = UO.WorldNum();
var rows = UO.GetLandTilesArray(x, y, x + 2, y + 2, map, 0x0003);
UO.Print("Records: " + Convert.ToString(ArrayLength(rows)));

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;

Parameter und Ablauf:

• Der Bereich 2×2 wird vom größeren Winkel auf den kleineren übertragen. Der Algorithmus selbst normalisiert die Grenzen. Zeile – ein Datensatz; PrintTile wird vollständig deklariert und formatiert nur Zahlen, ohne etwas zu verschieben. graphic - type, x/y – Koordinaten, z – Höhe, hue – Farbe. Für Grundstücke wird eine Bedingung hue=0 übergeben: Es gibt kein Farbfeld im Grundstücksdatensatz.

return  RunScenario();
 object? RunScenario()
{
    var x = UO.GetX();
    var y = UO.GetY();
    var map = UO.WorldNum();
    var rows = UO.GetLandTilesArray(x + 1, y + 1, x, y, map, 0x0003);
    var i = 0;
    while (Truth(i < ArrayLength(rows)))
    {
        var row = rows[i];
        PrintTile(row[0], row[1], row[2], row[3], 0);
        i = i + 1;
    }

    return null;
}

void PrintTile(dynamic graphic, dynamic x, dynamic y, dynamic z, dynamic hue)
{
    UO.Print("Type=" + Convert.ToString(graphic) + " X=" + Convert.ToString(x) + " Y=" + Convert.ToString(y));
    UO.Print("Z=" + Convert.ToString(z) + " hue=" + Convert.ToString(hue));
}

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;

Parameter und Ablauf:

• Nicht mehr als drei Suchvorgänge für eine Zelle; zwischen Versuchen WaitAsync(250). Jeder Aufruf erzeugt ein neues Ergebnis. Die Länge Null bedeutet, dass es jetzt keine Übereinstimmungen gibt und dass das Objekt nicht dauerhaft auf dem Server fehlt.

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 x = UO.GetX();
        var y = UO.GetY();
        var map = UO.WorldNum();
        var attempt = 0;
        while (Truth(attempt < 3))
        {
            var rows = UO.GetLandTilesArray(x, y, x, y, map, 0x0003);
            UO.Print("Records: " + Convert.ToString(ArrayLength(rows)));
            attempt = attempt + 1;
            await Delay(250);
        }

        return null;
    }

    int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
    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: xmin (Any), ymin (Any), xmax (Any), ymax (Any), worldNum (Any), tileType (Any)

Ergebnis: dynamic / Any.

Beim Aufruf:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• InjectionScript.Runtime.InjectionApiUO.FindPortableTiles: FindPortableTiles(Arg(0), Arg(1), Arg(2), Arg(3), Arg(4), new[] { Arg(5) }, false).
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(0).

Interner Implementierungscode; kein eigenständiges Skript.

case "getlandtilesarray":

                    return FindPortableTiles(Arg(0), Arg(1), Arg(2), Arg(3), Arg(4), new[] { Arg(5) }, false);

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

dynamic UO.GetLandTilesArrayEx(object? xmin, object? ymin, object? xmax, object? ymax, object? worldNum, object? tileTypes);

Sucht nach Landplättchen bei graphic/type in einem Rechteck.

• xmin – Weltkoordinaten von zwei Winkeln, einschließlich; 0..65535. Die neu angeordneten Winkel werden normalisiert. Fläche nicht größer als 1 000 000 Zellen; Ungültige Grenzen verursachen einen Skriptfehler, bevor die Karte gelesen wird.
• ymin – Weltkoordinaten von zwei Winkeln, einschließlich; 0..65535. Die neu angeordneten Winkel werden normalisiert. Fläche nicht größer als 1 000 000 Zellen; Ungültige Grenzen verursachen einen Skriptfehler, bevor die Karte gelesen wird.
• xmax – Weltkoordinaten von zwei Winkeln, einschließlich; 0..65535. Die neu angeordneten Winkel werden normalisiert. Fläche nicht größer als 1 000 000 Zellen; Ungültige Grenzen verursachen einen Skriptfehler, bevor die Karte gelesen wird.
• ymax – Weltkoordinaten von zwei Winkeln, einschließlich; 0..65535. Die neu angeordneten Winkel werden normalisiert. Fläche nicht größer als 1 000 000 Zellen; Ungültige Grenzen verursachen einen Skriptfehler, bevor die Karte gelesen wird.
• worldNum – Karte/Facette 0..255; Verwenden Sie UO.WorldNum(). Eine andere Karte ergibt ein leeres Array. Wenn sich die Karte zwischen den Blöcken ändert, wird das Teilergebnis verworfen.
• tileTypes – Array aus numerischen graphic/type; jedes passende type wird eingeschaltet. Durch das Wiederholen von type werden keine Einträge dupliziert. Der Skalar wird auch als eins type angenommen. Leeres Array bedeutet alles type; Ein Array von einem 0 durchsucht nur 0.

Array von Einträgen [graphic, X, Y, Z]; alle Felder int. graphic – type der Erde, Z – ihr Fundament. Keine Übereinstimmungen: leeres Array. Die Menge ist ArrayLength(Ergebnis), nicht das Ergebnis selbst. Die Indizes beginnen mit 0. Dies ist kein bool-, serial- oder Pascal-Datensatz; Es gibt keinen siebten Ausgabeparameter.

• Lokale Daten werden gelesen. Die Suche ändert FindItem/FindCount nicht und führt keinen Verschiebungs-, Ziel- oder Netzwerkbefehl aus.
• Reihenfolge: X aufsteigend, innerhalb von X - Y aufsteigend. Aufzeichnungen einer Zelle bewahren die Reihenfolge der Brücke; Es ist nicht nach Entfernung oder Höhe sortiert.
• Die Suche wird in Blöcken von bis zu 32 Zellen mit einem Softbudget von etwa 1 ms verarbeitet. Die Stornierung wird zwischen den Portionen überprüft. Eine komplexe Zellen- oder Kaltablesung kann das Budget sprengen. Es ist besser, eine große Fläche zu unterteilen; Beim Lesen kann sich die Welt verändern.

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.

object? result = UO.GetLandTilesArrayEx(UO.X(), UO.Y(), UO.X() + 1, UO.Y() + 1, UO.WorldNum(), new[] { 0x0003 });
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

Parameter und Ablauf:

• x/y – Position self, Karte – aktuelle Karte. Die Region 3×3 umfasst die Grenzen. In Ex werden zwei type übertragen, in Normalform eines. Ändern Sie die Beispiele entsprechend Ihren Ressourcen. Dies ist ein graphic-Objekt, kein ID-Objekt.

dynamic[] types = new dynamic[checked((int)(1) + 1)];
types[0] = 0x0003;
types[1] = 0x0004;
var x = UO.GetX();
var y = UO.GetY();
var map = UO.WorldNum();
var rows = UO.GetLandTilesArrayEx(x, y, x + 2, y + 2, map, types);
UO.Print("Records: " + Convert.ToString(ArrayLength(rows)));

int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;

Parameter und Ablauf:

• Der Bereich 2×2 wird vom größeren Winkel auf den kleineren übertragen. Der Algorithmus selbst normalisiert die Grenzen. Zeile – ein Datensatz; PrintTile wird vollständig deklariert und formatiert nur Zahlen, ohne etwas zu verschieben. graphic - type, x/y – Koordinaten, z – Höhe, hue – Farbe. Für Grundstücke wird eine Bedingung hue=0 übergeben: Es gibt kein Farbfeld im Grundstücksdatensatz.

return  RunScenario();
 object? RunScenario()
{
    dynamic[] types = new dynamic[checked((int)(1) + 1)];
    types[0] = 0x0003;
    types[1] = 0x0004;
    var x = UO.GetX();
    var y = UO.GetY();
    var map = UO.WorldNum();
    var rows = UO.GetLandTilesArrayEx(x + 1, y + 1, x, y, map, types);
    var i = 0;
    while (Truth(i < ArrayLength(rows)))
    {
        var row = rows[i];
        PrintTile(row[0], row[1], row[2], row[3], 0);
        i = i + 1;
    }

    return null;
}

void PrintTile(dynamic graphic, dynamic x, dynamic y, dynamic z, dynamic hue)
{
    UO.Print("Type=" + Convert.ToString(graphic) + " X=" + Convert.ToString(x) + " Y=" + Convert.ToString(y));
    UO.Print("Z=" + Convert.ToString(z) + " hue=" + Convert.ToString(hue));
}

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;

Parameter und Ablauf:

• Nicht mehr als drei Suchvorgänge für eine Zelle; zwischen Versuchen WaitAsync(250). Jeder Aufruf erzeugt ein neues Ergebnis. Die Länge Null bedeutet, dass es jetzt keine Übereinstimmungen gibt und dass das Objekt nicht dauerhaft auf dem Server fehlt.

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()
    {
        dynamic[] types = new dynamic[checked((int)(1) + 1)];
        types[0] = 0x0003;
        types[1] = 0x0004;
        var x = UO.GetX();
        var y = UO.GetY();
        var map = UO.WorldNum();
        var attempt = 0;
        while (Truth(attempt < 3))
        {
            var rows = UO.GetLandTilesArrayEx(x, y, x, y, map, types);
            UO.Print("Records: " + Convert.ToString(ArrayLength(rows)));
            attempt = attempt + 1;
            await Delay(250);
        }

        return null;
    }

    int ArrayLength(object? value) => value is System.Array array ? array.Length : 0;
    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;
}