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

Home · C# · IDE · UO API · A–Z · Esempi · Lingue

Coordinate, distanze, linea di vista, capacità di attraversare il paese e dati cartografici. Ottenere un percorso è descritto separatamente in Movimento.

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

Ogni carta comando ha diversi scenari indipendenti: codice diretto, funzioni e classi. Di seguito sono selezionati brevi scenari; restrizioni e un'analisi completa sono nelle carte.

Parametri, risultato e tutti gli scenari

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;

Parametri, risultato e tutti gli scenari

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

Aggiunge una voce statica personalizzata allo stato dello script locale. Il numerico graphic viene utilizzato per il controllo degli ostacoli locali da parte del pathfinder; l'oggetto non viene creato sul server. Una chiamata a due argomenti con testo non numerato preserva i valori legacy e non aggiunge elettricità statica al pathfinder.

• staticItem: valore numerico graphic o testo precedente.
• worldNum - indice della scheda per la registrazione o statico locale.
• graphic — ID statico da 0 a 65535.
• z — altezza. Quando aggiunto a Pathfinder, il valore è limitato all'intervallo di byte con segno.
• hue - hue; quando aggiunto, limitato all'intervallo da 0 a 65535.
• map — indice della mappa; per l'elaborazione manager, l'intervallo è limitato a 0–255.
• x - Statistiche personalizzate del Mondo X; int. Il manager accetta le coordinate all'interno della mappa attualmente caricata.
• y - Statistiche personalizzate del Mondo Y; int. Il manager accetta le coordinate all'interno della mappa attualmente caricata.

Positivo ID della voce creata. Per la forma a sei parametri, i negativi graphic, x, y o map, così come graphic sopra 65535 danno come risultato -1. ID può essere passato a UO.UserStaticExists, UO.RemoveUserStatic o utilizzato per controllare/eliminare un record legacy. Il ID restituito di per sé non conferma che lo statico sarà visibile o applicato sul server.

• • UO.AddUserStatic('tree', 0) - poiché tree non è un numero, salva una coppia di valori originali come record legacy nello stato di runtime; pathfinder non lo usa.
• Una chiamata a due parametri con il numerico graphic aggiunge lo statico di quel graphic alle coordinate attuali del personaggio, con z e hue 0 del personaggio.
• La chiamata a sei parametri aggiunge una statica con i dati graphic, coordinate, altitudine, hue e mappa. Il pathfinding ne tiene conto solo sulla mappa attiva e in base ai flag graphic nei Tiledata del client.

Queste voci sono locali nel client di script: non creano un oggetto di gioco, non effettuano una richiesta di rete o modificano i dati di shard.

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

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

Parametri e flusso di esecuzione:

• Salva la coppia come dati legacy; il testo StaticItem non crea un ostacolo al pathfinder.

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

Parametri e flusso di esecuzione:

• Il numero graphic viene aggiunto alla posizione del personaggio sulla mappa corrente.

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

Parametri e flusso di esecuzione:

• Aggiungi esplicitamente lo statico locale graphic alla posizione specificata e alla mappa specificata.

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# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

Parametri: staticItem (Any), worldNum (Any)

Risultato: dynamic / Any.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

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

                }

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

Risultato: int / Integer.

Durante la chiamata:

• 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]).

La chiamata esegue il delegate del gestore memorizzato. Il metodo di registrazione lo crea durante la costruzione dell’API.

Codice interno di implementazione; non è uno script autonomo.

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

Verifica la passabilità locale di una linea tra due punti sulla mappa tramite CheckPortableLineOfSight.

• xfrom — Sorgente X: 0..65535.
• yfrom — Sorgente Y: 0..65535.
• zfrom - Z iniziale, int.
• xto - Fine X: 0..65535.
• yto - Fine Y: 0..65535.
• zto — Z finale, int.
• worldNum - 0..255. Un raggio di lunghezza diversa da zero legge solo _world.Map/World.Map attualmente caricato: tramite CheckWorldStep è necessario WorldNum == _world.MapIndex e un Player.Pathfinder live. Un altro aspetto non è caricato o richiesto; non c'è mappa/personaggio/esploratore o il passaggio non è disponibile - 0. Escludendo X/Y identici si salta l'intero ciclo di celle: con X/Y in 0..65535, WorldNum in 0..255 e abs(Zfrom-Zto)<=20 restituisce 1 anche senza carta caricata o con un numero di carta diverso. Questa non è una prova della geometria o della raggiungibilità. Il risultato è locale, non una soluzione server LOS.

int 1 — il raggio locale ha raggiunto X/Y e l'altezza finale differisce da Zto di non più di 20; 0—coordinate, ostacolo o limite di controllo non validi.

• Il raggio viaggia utilizzando l'algoritmo di Bresenham, con un massimo di passi 4096. Su ciascuna cella vengono presi in considerazione BadLocations, CheckWorldStep e l'altezza restituita.
• Quando LosOptions != 0 viene utilizzato inoltre CheckLosCell; bit 0x100 controlla entrambi i quadrati laterali della diagonale. Il controllo della geometria locale non convalida le regole LOS specifiche del server e non sposta nulla.
• Il byte basso (valore & 0xFF) seleziona l'algoritmo 1..4; altri valori di byte bassi in CheckLosCell utilizzano l'algoritmo 3. Gli algoritmi 1/2 bloccano Muro e Invalicabile, 3 inoltre NoShoot e 4 abilita NoShoot solo con 0x200 e consente ostacoli Finestra solo con 0x400. Il bit 0x100 controlla inoltre entrambe le celle laterali di ciascun passaggio del raggio diagonale per qualsiasi algoritmo selezionato. value=0 disabilita i controlli aggiuntivi CheckLosCell/diagonale, ma rimangono BadLocations e CheckWorldStep. Ad esempio 4+0x100+0x200+0x400 seleziona personalizzato con tre flag; setter memorizza l'int originale, non l'algoritmo normalizzato.
• Un raggio di lunghezza diversa da zero legge solo _world.Map/World.Map attualmente caricato: tramite CheckWorldStep è necessario WorldNum == _world.MapIndex e un Player.Pathfinder live. Un altro aspetto non è caricato o richiesto; non c'è mappa/personaggio/esploratore oppure il passaggio non è disponibile - 0. Escludendo X/Y identici si salta l'intero ciclo di celle: con X/Y in 0..65535, WorldNum in 0..255 e abs(Zfrom-Zto)<=20 restituisce 1 anche senza carta caricata o con un numero di carta diverso. Questa non è una prova della geometria o della raggiungibilità. Il risultato è locale, non una soluzione server LOS.
• CheckLosCell ignora il Land/Static/Multi/Item caricato di una cella. Blocchi di terra invalicabili con abs(rayZ-land.Z)<=20. I flag Static/Multi/Item sono validi solo nell'intervallo tile.Z-2 .. tile.Z+max(1,Height)+2; La finestra personalizzata consentita viene saltata finché non viene selezionato Muro/Invalicabile/NoShoot. Il raggio X/Y utilizza Bresenham, massimo 4096 passi; Z è presa dalle superfici CheckWorldStep, non interpolata su Zto, la tolleranza dell'altezza finale è 20.

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

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

Parametri e flusso di esecuzione:

• I punti identici passano all'interno della mappa X/Y accettabile.

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

Parametri e flusso di esecuzione:

• L'altezza e la permeabilità della cella vicina vengono lette dalla mappa locale.

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

Parametri e flusso di esecuzione:

• Una X negativa viene scartata con risultato 0 senza passare per la mappa.

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# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

Parametri: xfrom (Any), yfrom (Any), zfrom (Any), xto (Any), yto (Any), zto (Any), worldNum (Any)

Risultato: dynamic / Any.

Durante la chiamata:

• 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).

Codice interno di implementazione; non è uno script autonomo.

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();

Rimuove tutte le voci di runtime statiche dell'utente e gli oggetti del gestore statico locale.

Non ci sono parametri.

void: nessun valore restituito.

• State.UserStatics e gli oggetti manager vengono cancellati. I file della mappa caricati e gli elementi del real server non vengono eliminati.

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il comando è un’istruzione separata. Il messaggio precedente indica l’inizio della chiamata e non conferma un’azione del server.

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

Parametri e flusso di esecuzione:

• Rimuove tutte le voci di runtime statiche dell'utente e gli oggetti del gestore statico locale.

UO.ClearUserStatics();

Parametri e flusso di esecuzione:

• Aggiungi uno statico locale sulla cella corrente, quindi rimuovi tutti gli statici personalizzati.

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

Parametri e flusso di esecuzione:

• La cancellazione di un set vuoto è accettabile e non crea una nuova impostazione.

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# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

Parametri: Nessun parametro.

Risultato: void / Unit.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

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

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

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

Analizza una maschera numerica di flag di riquadro in un array di nomi di enumerazione TileFlag.

• group - int: solo 1 o 2 abilitano la conversione; qualsiasi altro valore risulta in un array vuoto.
• value — Una maschera che Arg converte in un int con segno 32-bit, quindi il bridge porta a ulong. Per i flag ad alto 64 bit, questo modulo non preserva la maschera completa.

Matrice di stringhe denominate diverse da zero TileFlag i cui bit sono completamente presenti nella maschera. La maschera 0 produce un array vuoto.

• I gruppi 1 e 2 utilizzano la stessa Enum.GetValues anziché directory diverse. Questa è una trasformazione della maschera locale; i Tiledata non sono richiesti.
• La registrazione API utilizza object?, ma il dispatcher Arg(1) invia int. Il segno negativo int si estende quando lanciato a ulong. GetTileFlags restituisce anche solo i bit bassi 32 come firmati int: questa coppia compatibile non fornisce l'intero contratto Tiledata a 64 bit.

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

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

Parametri e flusso di esecuzione:

• Nella maschera 0 non è presente alcun flag diverso da zero.

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

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

Parametri e flusso di esecuzione:

• L'array contiene i nomi reali TileFlag della maschera selezionata.

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;

Parametri e flusso di esecuzione:

• Il gruppo 0 non è accettato da questo comando e restituisce un array vuoto.

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# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

Parametri: group (Any), value (Any)

Risultato: dynamic / Any.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

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

Calcola la distanza in celle tra due punti del mondo: la maggiore delle differenze assolute tra X e Y.

• xfrom — Coordinata X del punto iniziale.
• yfrom — Coordinata Y del punto iniziale.
• xto — La coordinata di assegnazione X.
• yto — La coordinata di assegnazione Y.

int — distanza in celle, non negativa per coordinate valide. 0 significa lo stesso XY, 1 - una cella. Questa è una quantità, non un segno di successo. Una distanza di confronto separata <= 2 restituisce bool true o false; la distanza stessa rimane int.

• Calcola solo le coordinate: nessun batch, nessuna attesa, nessun caricamento della mappa, nessun controllo degli ostacoli, nessuna Z, nessuna mappa del mondo. La squadra non cerca un percorso percorribile e non garantisce il raggiungimento dell'obiettivo. I punti devono appartenere allo stesso sistema di coordinate; evitare gli ostacoli può allungare il percorso.
• Sono necessari tutti e quattro i parametri. Invia le coordinate mondiali int nell'intervallo documentato 0..65535. object? nella firma indica un adattatore universale, non il ID dell'articolo. Questi comandi non hanno valori predefiniti, coordinate all'interno del baule, quinto Z e sovraccarico con un oggetto.
• Formula: Max(Abs(Xa-Xda), Abs(Ya-Yda)). Quando riorganizzi i punti, il risultato è lo stesso. Questa non è la distanza euclidea, non la somma delle differenze e non il numero di passi per aggirare un ostacolo.

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

var result = UO.Dist(100, 100, 103, 104);
UO.Print("Dist: " + Convert.ToString(result));

Parametri e flusso di esecuzione:

• Da (100,100) a (103,104): le differenze assolute sono 3 e 4, con un massimo di 4. Rendimenti principali int 4.
• int — distanza in celle, non negativa per coordinate valide. 0 significa lo stesso XY, 1 - una cella. Questa è una quantità, non un segno di successo. Una distanza di confronto separata <= 2 restituisce bool true o false; la distanza stessa rimane int.
• Formula: Max(Abs(Xa-Xda), Abs(Ya-Yda)). Quando riorganizzi i punti, il risultato è lo stesso. Questa non è la distanza euclidea, non la somma delle differenze e non il numero di passi per aggirare un ostacolo.

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

Parametri e flusso di esecuzione:

• Da (100,100) a (101,99) la distanza è 1. Un confronto separato della distanza<=2 dà true=1. Principale restituisce "1:1": la prima unità è la distanza, la seconda è il risultato logico del confronto.
• int — distanza in celle, non negativa per coordinate valide. 0 significa lo stesso XY, 1 - una cella. Questa è una quantità, non un segno di successo. Una distanza di confronto separata <= 2 restituisce bool true o false; la distanza stessa rimane int.
• Formula: Max(Abs(Xa-Xda), Abs(Ya-Yda)). Quando riorganizzi i punti, il risultato è lo stesso. Questa non è la distanza euclidea, non la somma delle differenze e non il numero di passi per aggirare un ostacolo.

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

Parametri e flusso di esecuzione:

• UO.Dist restituisce 4. RebuildTileDistance calcola le differenze tramite Abs, le confronta e restituisce quella più grande, così come 4. Il principale restituisce "4:4". L'assistente è mostrato completamente nell'esempio e non è un altro comando del motore.
• int — distanza in celle, non negativa per coordinate valide. 0 significa lo stesso XY, 1 - una cella. Questa è una quantità, non un segno di successo. Una distanza di confronto separata <= 2 restituisce bool true o false; la distanza stessa rimane int.
• Formula: Max(Abs(Xa-Xda), Abs(Ya-Yda)). Quando riorganizzi i punti, il risultato è lo stesso. Questa non è la distanza euclidea, non la somma delle differenze e non il numero di passi per aggirare un ostacolo.

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# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

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

Risultato: int / Integer.

Durante la chiamata:

• 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)).

Codice interno di implementazione; non è uno script autonomo.

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

Misura la distanza nelle celle in base alle differenze X/Y massime. Questa è una stima geometrica senza pathfinding.

• id — Un argomento: serial o l'alias dell'oggetto caricato, la distanza alla quale vuoi arrivare.
• x — Due argomenti: destinazione mondiale. L'inizio è GetX(self), GetY(self).
• y — Due argomenti: destinazione mondiale. L'inizio è GetX(self), GetY(self).
• id1 - Nella forma a tre argomenti - serial/alias dell'oggetto le cui coordinate fungono da origine.
• x1 — Nella forma a quattro argomenti, le coordinate dell'origine. Nessun oggetto è necessario per questo modulo.
• y1 — Nella forma a quattro argomenti, le coordinate dell'origine. Nessun oggetto è necessario per questo modulo.
• x2 — Nei moduli con tre/quattro argomenti, le coordinate finali. Non confonderli con serial del secondo oggetto.
• y2 — Nei moduli con tre/quattro argomenti, le coordinate finali. Non confonderli con serial del secondo oggetto.

int - max(abs(x2-x1), abs(y2-y1)): orizzontale, verticale e diagonale rispetto a una cella adiacente hanno una distanza 1. L'altezza Z e gli ostacoli non vengono presi in considerazione. Per l'incognita serial, la forma ad un argomento restituisce 0; per un oggetto esistente in assenza di un carattere - 65535. Per id1 sconosciuto, la forma a tre argomenti utilizza (0,0), quindi controlla prima Exists(id1).

• La forma a oggetto singolo utilizza l'attuale centro del raggio World.RangeSize e l'ultima posizione nella coda dei passi del mob in movimento. Durante il movimento, il risultato può differire dal calcolo tramite GetX/GetY.
• I moduli delle coordinate funzionano con i numeri passati. Per le coordinate del gioco, utilizzare l'intervallo 0..65535; i valori int estremi e l'overflow della differenza non sono coordinate supportate.
• La squadra non promette che l'obiettivo sarà raggiungibile. Per muoverti, hai bisogno di MoveXY/NewMoveXY e controllarne il risultato; i muri possono allungare il percorso vero e proprio.

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

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

Parametri e flusso di esecuzione:

• l'obiettivo è serial, non type. Il controllo Exists impedisce che lo zero di un oggetto sconosciuto venga scambiato per un bersaglio vicino.
• distance<=2 controlla la distanza X/Y. Visibilità e passabilità vengono controllate separatamente.

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;

Parametri e flusso di esecuzione:

• x1=100, y1=200, x2=103, y2=204. Le differenze sono 3 e 4.
• Il risultato è 4, non 7 e non l'euclideo 5.

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

Parametri e flusso di esecuzione:

• I due argomenti x/y utilizzano la posizione corrente di self. I tre argomenti id1/x2/y2 consentono di specificare esplicitamente l'oggetto iniziale.
• A una posizione costante, entrambe le quantità sono uguali a 3. Le coordinate devono rimanere entro i confini della mappa.

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# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

Parametri: id (Any/Integer/String)

Risultato: int / Any.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

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

Parametri: id (Any/Integer/String)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

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

Parametri: id (Any/Integer/String)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

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

Parametri: x (Integer), y (Integer)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

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

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

Risultato: int / Integer.

Durante la chiamata:

• 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).

Codice interno di implementazione; non è uno script autonomo.

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

        }

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

Risultato: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.GetDistance.

Codice interno di implementazione; non è uno script autonomo.

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

Restituisce il record catastale esteso della cella selezionata.

• x — cella X della mappa attualmente caricata; coordinate del mondo, non posizione all'interno del gump.
• y — cella Y della mappa attualmente caricata; coordinate del mondo, non posizione all'interno del gump.
• map — Numero della carta. Se questo argomento non è presente nel modulo selezionato, viene utilizzata la mappa corrente. Il vero client legge solo i riquadri dalla mappa attualmente caricata.

Matrice di campi 11 di un record; gli indici iniziano con 0:

• [0] kind — string: "terra", "statico" o "object".
• [1] serial - int: serial voce dinamica; per terra/statico è 0.
• [2] graphic - int: grafica type.
• [3] x, [4] y - int: coordinate mondiali della cella.
• [5] z - int: l'altezza della base nel mondo.
• [6] hue - int: colore, vicino al suolo 0.
• [7] flags - int: bit 32 bassi di flag di Tiledata.
• [8] name - string: nome da Tiledata.
• [9] layer - int: strato di attrezzature da Tiledata, vicino al suolo 0; non un indice statico.
• [10] height - int: altezza graphic dai dati piastrellati, vicino al suolo 0; non la coordinata Z.

Un array vuoto [] significa nessuna voce o una carta/cella inaccessibile. Per GetStaticTileAt, un indice negativo/troppo grande produce anche []; L'overflow dell'indice non seleziona la voce di qualcun altro.

• I dati si riferiscono alla mappa attualmente caricata. Un'altra carta o cella irraggiungibile risulta in un array vuoto. Le query dirette sui riquadri possono inoltre segnalare mancate corrispondenze della mappa; GetWorldCell e GetWorldTilesArray restituiscono immediatamente un array vuoto senza tale messaggio.
• Gli indici degli array iniziano con 0. Controllare ArrayLength prima di leggere il campo. Z sta per altitudine mondiale; layer è la proprietà dell'attrezzatura da Tiledata e indice è il numero di serie della voce della cella.

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

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

Parametri e flusso di esecuzione:

• x/y: posizione del carattere; la carta viene abbassata e selezionata automaticamente. Per GetStaticTileAt indice=0 indica la prima voce.
• I campi [2], [5], [9] hanno significati diversi; tutti vengono letti solo dopo aver controllato la lunghezza di 11.

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;

Parametri e flusso di esecuzione:

• Vengono utilizzate le stesse coordinate; GetStaticTileAt legge indice=0.
• piastrella[8] è la stringa del titolo, piastrella[10] è la dimensione dell'altezza da Tiledata, non la base Z.

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;

Parametri e flusso di esecuzione:

• WaitTargetTile riceve graphic, x, y, z dai campi 2…5.
• Questa è solo la preparazione per il prossimo obiettivo. L'esempio non attiva uno strumento o un incantesimo. serial=0 per i dati statici non deve essere passato come ID dell'elemento.

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# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

Parametri: x (Any), y (Any)

Risultato: dynamic / Any.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

public InjectionValue GetLandTileAt(InjectionValue x, InjectionValue y)

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

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

Risultato: dynamic / Any.

Durante la chiamata:

• 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).

Codice interno di implementazione; non è uno script autonomo.

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

Legge il record di riferimento del terreno esteso da Tiledata.

• tile è una voce Grafica/type, non serial e non un indice all'interno di una cella. Il tavolo del terreno viene scelto dal nome stesso della squadra.

Matrice di campi 7 per graphic validi. Tutti i campi int tranne il nome (string):

• [0] graphic — Registrazioni graphic/type.
• [1] flags - bit flag 32 di ordine basso.
• [2] name - nome da Tiledata (string).
• [3] texId - ID trame del terreno.
• [4] wet — 1 se installato bagnato, altrimenti 0.
• [5] impassable — 1 se impraticabile, altrimenti 0.
• [6] noDiagonal — 1 se noDiagonal, altrimenti 0.

Per un graphic non valido non ci sono proprietà di riferimento: viene restituito un breve array [переданный graphic, 0, ""]. Controlla l'intera lunghezza prima di leggere le proprietà. Questo non è un record Pascal o un elenco di oggetti.

• Il comando legge Tiledata e non richiede un elemento con quello graphic nel mondo. I flag descrivono la risorsa; il risultato non sostituisce un controllo completo del percorso.

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

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

Parametri e flusso di esecuzione:

• Tile è il numero graphic della tabella selezionata.
• data[2] contiene il nome. Il controllo della lunghezza separa una voce completa da una voce breve di un graphic non valido.

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;

Parametri e flusso di esecuzione:

• data[5] è un campo invalicabile separato: 1 (condizione soddisfatta), 0 (condizione non soddisfatta).
• Questo controllo non tiene conto degli altri oggetti nella cella o delle abilità del personaggio.

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;

Parametri e flusso di esecuzione:

• data[0] ripete il graphic trasmesso, data[1] è una maschera di flag generale.
• La maschera può contenere più bit contemporaneamente; il suo valore numerico non è 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# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

Parametri: tile (Any)

Risultato: dynamic / Any.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

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

Cerca le tessere terreno in graphic/type in un rettangolo.

• xmin - Coordinate mondiali di due angoli, inclusi; 0..65535. Gli angoli riorganizzati sono normalizzati. Area non superiore a 1 000 000 celle; i confini non validi causano un errore di script prima che la mappa venga letta.
• ymin - Coordinate mondiali di due angoli, inclusi; 0..65535. Gli angoli riorganizzati sono normalizzati. Area non superiore a 1 000 000 celle; i confini non validi causano un errore di script prima che la mappa venga letta.
• xmax - Coordinate mondiali di due angoli, inclusi; 0..65535. Gli angoli riorganizzati sono normalizzati. Area non superiore a 1 000 000 celle; i confini non validi causano un errore di script prima che la mappa venga letta.
• ymax - Coordinate mondiali di due angoli, inclusi; 0..65535. Gli angoli riorganizzati sono normalizzati. Area non superiore a 1 000 000 celle; i confini non validi causano un errore di script prima che la mappa venga letta.
• worldNum — Mappa/sfaccettatura 0..255; utilizzare UO.WorldNum(). Un'altra mappa fornisce un Array vuoto. Se la mappa cambia tra i blocchi, il risultato parziale viene scartato.
• tileType - Una tessera graphic/type, solitamente 0..65535; questo non è serial. 0 è l'esatto graphic 0, -1 non significa alcun type. Un type non corrispondente dà un risultato vuoto.

Array di voci [graphic, X, Y, Z]; tutti i campi int. graphic - type della terra, Z - le sue fondamenta. Nessuna corrispondenza: array vuoto. La quantità è ArrayLength(risultato), non il risultato stesso. Gli indici iniziano con 0. Questo non è un record bool, serial o Pascal; non esiste un settimo parametro di output.

• Vengono letti i dati locali. La ricerca non cambia FindItem/FindCount e non esegue un comando di spostamento, bersaglio o di rete.
• Ordine: X ascendente, all'interno di X - Y ascendente. Le registrazioni di una cella preservano l'ordine del bridge; non è ordinato per distanza o altezza.
• La ricerca viene elaborata in blocchi fino a 32 celle con un budget flessibile di circa 1 ms. L'annullamento viene controllato tra una porzione e l'altra. Una cella complessa o una lettura a freddo potrebbero superare il budget. È meglio dividere una vasta area; il mondo può cambiare durante la lettura.

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

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

Parametri e flusso di esecuzione:

• x/y — posizione self, mappa — mappa corrente. La regione 3×3 comprende i confini. Nell'Es vengono trasmessi due type, nella forma normale uno. Modifica i campioni in base alle tue risorse; questo è un oggetto graphic, non un oggetto ID.

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;

Parametri e flusso di esecuzione:

• La regione 2×2 viene trasferita dall'angolo maggiore a quello minore. L'algoritmo stesso normalizza i confini. riga: un record; PrintTile viene dichiarato nella sua interezza e formatta solo numeri, senza spostare nulla. graphic - type, x/y - coordinate, z - altezza, hue - colore. Per i terreni viene passato il condizionale hue=0: non vi è alcun campo colore nel record dei terreni.

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;

Parametri e flusso di esecuzione:

• Non più di tre ricerche per una cella; tra i tentativi WaitAsync(250). Ogni chiamata crea un nuovo risultato. La lunghezza zero significa che non ci sono corrispondenze ora, piuttosto che l'oggetto manca permanentemente dal server.

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# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

Parametri: xmin (Any), ymin (Any), xmax (Any), ymax (Any), worldNum (Any), tileType (Any)

Risultato: dynamic / Any.

Durante la chiamata:

• 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).

Codice interno di implementazione; non è uno script autonomo.

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

Cerca le tessere terreno in graphic/type in un rettangolo.

• xmin - Coordinate mondiali di due angoli, inclusi; 0..65535. Gli angoli riorganizzati sono normalizzati. Area non superiore a 1 000 000 celle; i confini non validi causano un errore di script prima che la mappa venga letta.
• ymin - Coordinate mondiali di due angoli, inclusi; 0..65535. Gli angoli riorganizzati sono normalizzati. Area non superiore a 1 000 000 celle; i confini non validi causano un errore di script prima che la mappa venga letta.
• xmax - Coordinate mondiali di due angoli, inclusi; 0..65535. Gli angoli riorganizzati sono normalizzati. Area non superiore a 1 000 000 celle; i confini non validi causano un errore di script prima che la mappa venga letta.
• ymax - Coordinate mondiali di due angoli, inclusi; 0..65535. Gli angoli riorganizzati sono normalizzati. Area non superiore a 1 000 000 celle; i confini non validi causano un errore di script prima che la mappa venga letta.
• worldNum — Mappa/sfaccettatura 0..255; utilizzare UO.WorldNum(). Un'altra mappa fornisce un Array vuoto. Se la mappa cambia tra i blocchi, il risultato parziale viene scartato.
• tileTypes — Array di numerici graphic/type; ogni type corrispondente è acceso. La ripetizione di type non duplica le voci. Anche lo scalare viene preso come uno type. Array vuoto significa tutto type; un array di uno 0 cerca solo 0.

Array di voci [graphic, X, Y, Z]; tutti i campi int. graphic - type della terra, Z - le sue fondamenta. Nessuna corrispondenza: array vuoto. La quantità è ArrayLength(risultato), non il risultato stesso. Gli indici iniziano con 0. Questo non è un record bool, serial o Pascal; non esiste un settimo parametro di output.

• Vengono letti i dati locali. La ricerca non cambia FindItem/FindCount e non esegue un comando di spostamento, bersaglio o di rete.
• Ordine: X ascendente, all'interno di X - Y ascendente. Le registrazioni di una cella preservano l'ordine del bridge; non è ordinato per distanza o altezza.
• La ricerca viene elaborata in blocchi fino a 32 celle con un budget flessibile di circa 1 ms. L'annullamento viene controllato tra una porzione e l'altra. Una cella complessa o una lettura a freddo potrebbero superare il budget. È meglio dividere una vasta area; il mondo può cambiare durante la lettura.

Ogni esempio può essere salvato come file separato .csx ed eseguito in IDE. Le funzioni oggetto UO e attesa forniscono l'host della sessione di gioco corrente. Sostituisci i nomi, le coordinate e gli indirizzi demo serial con i tuoi.

Esegui questo codice in un file .csx separato. Gli argomenti sono visibili nella chiamata; sostituisci nomi, serial e indirizzi di esempio con i tuoi.

Il risultato di una sola chiamata viene mostrato nel diario. Un numero non viene convertito in bool; per un array viene mostrato il numero di elementi.

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

Parametri e flusso di esecuzione:

• x/y — posizione self, mappa — mappa corrente. La regione 3×3 comprende i confini. Nell'Es vengono trasmessi due type, nella forma normale uno. Modifica i campioni in base alle tue risorse; questo è un oggetto graphic, non un oggetto ID.

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;

Parametri e flusso di esecuzione:

• La regione 2×2 viene trasferita dall'angolo maggiore a quello minore. L'algoritmo stesso normalizza i confini. riga: un record; PrintTile viene dichiarato nella sua interezza e formatta solo numeri, senza spostare nulla. graphic - type, x/y - coordinate, z - altezza, hue - colore. Per i terreni viene passato il condizionale hue=0: non vi è alcun campo colore nel record dei terreni.

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;

Parametri e flusso di esecuzione:

• Non più di tre ricerche per una cella; tra i tentativi WaitAsync(250). Ogni chiamata crea un nuovo risultato. La lunghezza zero significa che non ci sono corrispondenze ora, piuttosto che l'oggetto manca permanentemente dal server.

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