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

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

1 · 2

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

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

Legge il campo Z dell'oggetto caricato o del carattere corrente.

• id è il Serial/ID dell'oggetto, non graphic/type. Numero, stringa esadecimale, nome standard self/backpack/lasttarget/lastobject/lastcontainer/laststatus/finditem/lastcorpse o nome AddObject. L'alias deve essere impostato; l'esistenza è controllata da Exists. La forma registrata senza argomenti utilizza self.

int è l'altezza di Z. Per un oggetto sconosciuto, viene restituito 0. Anche lo zero è una coordinata valida. L'altezza può essere negativa; Questo non è un livello di attrezzatura o un indice statico.

• Vengono letti gli ultimi dati già noti al client; la richiesta di aggiornamento non viene inviata al server.
• Un oggetto sconosciuto e una proprietà non ancora recuperata possono avere un valore nullo/vuoto. Controlla Exists e le condizioni di una particolare azione.
• Per un personaggio o un oggetto a terra, questa è la coordinata del mondo. L'oggetto all'interno del contenitore ha una posizione X/Y all'interno del gump; il comando non li traduce nelle coordinate mondiali del proprietario.
• Viene letta la coordinata corrente dell'oggetto. I passaggi in attesa di conferma non vengono convertiti in calcoli di percorso da questo comando.

int z = UO.GetZ();
UO.Print($"Z = {z}");

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

Parametri e flusso di esecuzione:

• La forma senza argomento seleziona self, il carattere corrente.
• la posizione contiene l'altezza di Z, non serial.

var position = UO.GetZ();
UO.Print("Z: " + Convert.ToString(position));

Parametri e flusso di esecuzione:

• lasttarget dovrebbe puntare al personaggio o all'oggetto caricato a terra.
• delta: differenza lungo un asse. Non è la lunghezza del percorso; il valore potrebbe essere negativo.

return  RunScenario();
 object? RunScenario()
{
    var other = UO.GetSerial("lasttarget");
    if (Truth(UO.Exists(other)))
    {
        var delta = UO.GetZ(other) - UO.GetZ();
        UO.Print("Difference: " + Convert.ToString(delta));
    }

    return null;
}

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:

• id="self" è una forma esplicita di selezione dei caratteri. UO.Wait=500 millisecondi.
• Il confronto mostra la variazione solo nell'asse Z. Le modifiche nell'altro asse o nella rotazione non vengono qui prese in considerazione.

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

    async public Task<object?> RunScenarioAsync()
    {
        var before = UO.GetZ("self");
        await Delay(500);
        var after = UO.GetZ("self");
        if (Truth(before != after))
        {
            UO.Print("Coordinate changed");
        }

        return null;
    }

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

C# 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: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.GetZ.
• InjectionScript.Runtime.InjectionApiUO.GetZ: GetZ("self").

Codice interno di implementazione; non è uno script autonomo.

public int GetZ() => GetZ("self");

Parametri: id (Any/Integer/String)

Risultato: int / Any.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "getz": return new InjectionValue(bridge.GetZ(Arg(0, bridge.Self)));

Parametri: id (Any/Integer/String)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

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

Parametri: id (Any/Integer/String)

Risultato: int / Integer.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

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

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

int UO.IsMineTile(object? x, object? y);

Controlla le caratteristiche di una cella rispetto ai dati della mappa locale.

• x — int X celle della carta corrente; coordinata mondiale, non un pixel dello schermo.
• y — int Y celle della carta corrente; coordinata mondiale, non un pixel dello schermo.

Flag numerico int: 1 — è stato trovato un oggetto corrispondente alla condizione; 0 - non esiste un oggetto del genere oppure la cella/carta è inaccessibile.

• AnyTileAt bypassa la catena TNext della cella caricata. Condizione IsMineTile: Statico/Multi con StaticFilters.IsRock o un nome contenente grotta, montagna o roccia, senza distinzione tra maiuscole e minuscole.
• Il controllo descrive i dati/filtri locali. Non promette la disponibilità di una risorsa estratta, la capacità di attraversare il paese, un raggio d'azione o l'autorizzazione del server per l'estrazione mineraria.

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

Parametri e flusso di esecuzione:

• Controlla le caratteristiche di una cella rispetto ai dati della mappa locale.

UO.Print(UO.IsMineTile(UO.GetX(), UO.GetY()));

Parametri e flusso di esecuzione:

• AnyTileAt bypassa la catena TNext della cella caricata. Condizione IsMineTile: Statico/Multi con StaticFilters.IsRock o un nome contenente grotta, montagna o roccia, senza distinzione tra maiuscole e minuscole.

return  RunScenario();
 object? RunScenario()
{
    var x = UO.GetX() + 1;
    var y = UO.GetY();
    if (Truth(UO.IsMineTile(x, y)))
    {
        UO.Print("Local tile predicate matched");
    }

    return null;
}

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:

• Il controllo descrive i dati/filtri locali. Non promette la disponibilità di una risorsa estratta, la capacità di attraversare il paese, un raggio d'azione o l'autorizzazione del server per l'estrazione mineraria.

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

     public object? RunScenario()
    {
        var x = UO.GetX();
        var y = UO.GetY();
        var before = UO.IsMineTile(x, y);
        UO.Wait(500);
        UO.Print(before = UO.IsMineTile(x, y));
        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: x (Any), y (Any)

Risultato: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.IsMineTile.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.IsMineTile: bridge.IsMineTile(NumberConversions.ToInt(x), NumberConversions.ToInt(y)).
• InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(x).

Codice interno di implementazione; non è uno script autonomo.

public int IsMineTile(InjectionValue x, InjectionValue y) => bridge.IsMineTile(NumberConversions.ToInt(x), NumberConversions.ToInt(y));

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

int UO.IsTreeTile(object? x, object? y);

Controlla le caratteristiche di una cella rispetto ai dati della mappa locale.

• x — int X celle della carta corrente; coordinata mondiale, non un pixel dello schermo.
• y — int Y celle della carta corrente; coordinata mondiale, non un pixel dello schermo.

Flag numerico int: 1 — è stato trovato un oggetto corrispondente alla condizione; 0 - non esiste un oggetto del genere oppure la cella/carta è inaccessibile.

• AnyTileAt bypassa la catena TNext della cella caricata. Condizione IsTreeTile: Statico/Multi riconosciuto da StaticFilters.IsTree.
• Il controllo descrive i dati/filtri locali. Non promette la disponibilità di una risorsa estratta, la capacità di attraversare il paese, un raggio d'azione o l'autorizzazione del server per l'estrazione mineraria.

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

Parametri e flusso di esecuzione:

• Controlla le caratteristiche di una cella rispetto ai dati della mappa locale.

UO.Print(UO.IsTreeTile(UO.GetX(), UO.GetY()));

Parametri e flusso di esecuzione:

• AnyTileAt bypassa la catena TNext della cella caricata. Condizione IsTreeTile: Statico/Multi riconosciuto da StaticFilters.IsTree.

return  RunScenario();
 object? RunScenario()
{
    var x = UO.GetX() + 1;
    var y = UO.GetY();
    if (Truth(UO.IsTreeTile(x, y)))
    {
        UO.Print("Local tile predicate matched");
    }

    return null;
}

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:

• Il controllo descrive i dati/filtri locali. Non promette la disponibilità di una risorsa estratta, la capacità di attraversare il paese, un raggio d'azione o l'autorizzazione del server per l'estrazione mineraria.

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

     public object? RunScenario()
    {
        var x = UO.GetX();
        var y = UO.GetY();
        var before = UO.IsTreeTile(x, y);
        UO.Wait(500);
        UO.Print(before = UO.IsTreeTile(x, y));
        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: x (Any), y (Any)

Risultato: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.IsTreeTile.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.IsTreeTile: bridge.IsTreeTile(NumberConversions.ToInt(x), NumberConversions.ToInt(y)).
• InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(x).

Codice interno di implementazione; non è uno script autonomo.

public int IsTreeTile(InjectionValue x, InjectionValue y) => bridge.IsTreeTile(NumberConversions.ToInt(x), NumberConversions.ToInt(y));

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

int UO.IsWaterTile(object? x, object? y);

Controlla le caratteristiche di una cella rispetto ai dati della mappa locale.

• x — int X celle della carta corrente; coordinata mondiale, non un pixel dello schermo.
• y — int Y celle della carta corrente; coordinata mondiale, non un pixel dello schermo.

Flag numerico int: 1 — è stato trovato un oggetto corrispondente alla condizione; 0 - non esiste un oggetto del genere oppure la cella/carta è inaccessibile.

• AnyTileAt bypassa la catena TNext della cella caricata. Condizione IsWaterTile: Atterra con TileData.IsWet o un oggetto con graphic statico valido e bandiera IsWet.
• Il controllo descrive i dati/filtri locali. Non promette la disponibilità di una risorsa estratta, la capacità di attraversare il paese, un raggio d'azione o l'autorizzazione del server per l'estrazione mineraria.

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

Parametri e flusso di esecuzione:

• Controlla le caratteristiche di una cella rispetto ai dati della mappa locale.

UO.Print(UO.IsWaterTile(UO.GetX(), UO.GetY()));

Parametri e flusso di esecuzione:

• AnyTileAt bypassa la catena TNext della cella caricata. Condizione IsWaterTile: Atterra con TileData.IsWet o un oggetto con graphic statico valido e bandiera IsWet.

return  RunScenario();
 object? RunScenario()
{
    var x = UO.GetX() + 1;
    var y = UO.GetY();
    if (Truth(UO.IsWaterTile(x, y)))
    {
        UO.Print("Local tile predicate matched");
    }

    return null;
}

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:

• Il controllo descrive i dati/filtri locali. Non promette la disponibilità di una risorsa estratta, la capacità di attraversare il paese, un raggio d'azione o l'autorizzazione del server per l'estrazione mineraria.

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

     public object? RunScenario()
    {
        var x = UO.GetX();
        var y = UO.GetY();
        var before = UO.IsWaterTile(x, y);
        UO.Wait(500);
        UO.Print(before = UO.IsWaterTile(x, y));
        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: x (Any), y (Any)

Risultato: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.IsWaterTile.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.IsWaterTile: bridge.IsWaterTile(NumberConversions.ToInt(x), NumberConversions.ToInt(y)).
• InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(x).

Codice interno di implementazione; non è uno script autonomo.

public int IsWaterTile(InjectionValue x, InjectionValue y) => bridge.IsWaterTile(NumberConversions.ToInt(x), NumberConversions.ToInt(y));

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

dynamic UO.IsWorldCellPassable(object? currX, object? currY, object? currZ, object? destX, object? destY, object? destZ, object? worldNum);

Controlla una transizione verso una cella del mondo adiacente e restituisce la bandiera passabile insieme all'altezza.

• currX — Coordinata X obbligatoria del mondo della cella sorgente. Intero 0..65535 all'interno della mappa caricata; questa non è una coordinata gump.
• currY — Coordinata Y obbligatoria del mondo della cella sorgente. Intero 0..65535 all'interno della mappa caricata; questa non è una coordinata gump.
• currZ - Altezza iniziale obbligatoria −128..127. Questa è l'altezza del mondo, non il numero del piano. L'altezza non valida viene rifiutata e non tagliata.
• destX — Coordinata X obbligatoria del mondo della cella bersaglio. Intero 0..65535 all'interno della mappa caricata; questa non è una coordinata gump.
• destY — Coordinata Y obbligatoria del mondo della cella bersaglio. Intero 0..65535 all'interno della mappa caricata; questa non è una coordinata gump.
• destZ - Ingresso obbligatorio Z di riserva, solitamente CurrZ. Questa non è una var: la variabile non cambia e non imposta il floor richiesto. Leggi l'altezza calcolata dal risultato [1]. Questo ponte restituisce sempre la sua altezza; l'argomento è necessario per la compatibilità con la forma Pascal.
• worldNum — Numero della carta obbligatoria: UO.WorldNum(). Viene controllata solo la mappa corrente con dimensioni note; L'altra mappa non verrà caricata.

Matrice di due int: [0] - passabilità, 1 (condizione soddisfatta), 0 (condizione non soddisfatta); [1] - calcolato Z. Solo il primo elemento è logico. L'array stesso non può essere paragonato a true. L'altezza 0/negativo è accettabile; per [0]=0 l'altezza non dimostra la raggiungibilità. Il rifiuto degli argomenti restituisce [0, CurrZ].

• Nessun movimento, apertura di porte, mirino o pacchetti di rete. Viene letta la geometria locale esistente; il server potrebbe successivamente rifiutare il passaggio. Due richieste possono vedere stati diversi.
• La cella adiacente è accettata (la differenza X/Y non è superiore a 1). Bersaglio più distante, uscita dalla mappa, assenza di un personaggio/carta e IsDestroyed dare un rifiuto prima del calcolo. Per un percorso completo, utilizzare GetPathArray o NewMoveXY.
• Lo stesso X/Y valido fornisce [1, CurrZ] senza controllo delle collisioni: nessun passaggio necessario. Questa non è una prova della capacità di fuggire dalla gabbia. Le condizioni del personaggio e le attuali regole di Pathfinder influenzano il passo adiacente; senza geometria caricata potrebbe essere rifiutato.

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.IsWorldCellPassable(UO.GetX(), UO.GetY(), UO.GetZ(), UO.GetX() + 1, UO.GetY(), UO.GetZ(), UO.WorldNum());
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

Parametri e flusso di esecuzione:

• x/y/z è la posizione iniziale, x+1/y è la cella adiacente, il sesto parametro z è la Z di riserva, l'ultimo è la carta corrente. result[0] viene controllato prima di utilizzare result[1].

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;

Parametri e flusso di esecuzione:

• proposedZ rimane 0 dopo la chiamata. targetZ è preso dal risultato[1], non dall'argomento. In caso di fallimento, l'esempio non fa inferenze sull'altezza.

return  RunScenario();
 object? RunScenario()
{
    var x = UO.GetX();
    var y = UO.GetY();
    var z = UO.GetZ();
    var proposedZ = 0;
    var result = UO.IsWorldCellPassable(x, y, z, x, y + 1, proposedZ, UO.WorldNum());
    if (Truth(result[0] == 1))
    {
        var targetZ = result[1];
        UO.Print("Input=" + Convert.ToString(proposedZ) + "; result=" + Convert.ToString(targetZ));
    }

    return null;
}

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:

• L'helper completo sotto Main accetta sorgente X/Y/Z, destinazione X/Y e mappa. Aggiunge il sesto argomento richiesto e restituisce solo int 1/0, non un array. Pertanto, il risultato di IsCellOpen può essere confrontato con true. Il codice non sposta il carattere.

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

     public object? RunScenario()
    {
        var x = UO.GetX();
        var y = UO.GetY();
        var openCell = IsCellOpen(x, y, UO.GetZ(), x + 1, y + 1, UO.WorldNum());
        if (Truth(Truth(openCell) == true))
        {
            UO.Print("Diagonal cell is locally passable");
        }

        return null;
    }

    dynamic IsCellOpen(dynamic x, dynamic y, dynamic z, dynamic toX, dynamic toY, dynamic map)
    {
        var cellResult = UO.IsWorldCellPassable(x, y, z, toX, toY, z, map);
        if (Truth(ArrayLength(cellResult) != 2))
        {
            return 0;
        }

        return cellResult[0];
    }

    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: currX (Any), currY (Any), currZ (Any), destX (Any), destY (Any), destZ (Any), worldNum (Any)

Risultato: dynamic / Array.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility::Arg: Arg(5).
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.CheckWorldStep: bridge.CheckWorldStep(Arg(0), Arg(1), Arg(2), Arg(3), Arg(4), Arg(6)).

Codice interno di implementazione; non è uno script autonomo.

case "isworldcellpassable":

                {

                    int destinationZFallback = Arg(5);

                    int[] step = bridge.CheckWorldStep(Arg(0), Arg(1), Arg(2), Arg(3), Arg(4), Arg(6));

                    int passable = step.Length > 0 ? step[0] : 0;

                    int destinationZ = step.Length > 1 ? step[1] : destinationZFallback;

                    return new InjectionValue(new[] { new InjectionValue(passable), new InjectionValue(destinationZ) });

                }

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

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

Legge o salva la maschera dei parametri locali LOS runtime.

• value - Opzionale int; nessun argomento di sola lettura. In questo thread, l'intervallo e i singoli bit non vengono controllati. Il minore byte (valore & 0xFF) seleziona l'algoritmo 1..4; altri valori del minore byte in CheckLosCell utilizzano l'algoritmo 3. Gli algoritmi 1/2 bloccano Muro e Invalicabile, 3 bloccano inoltre NoShoot e 4 abilitano NoShoot solo con 0x200 e consentono 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 conserva l'algoritmo originale int, non normalizzato.

int - state.LosOptions dopo l'eventuale scrittura. Questo è un codice/maschera di parametro, non un bool e non il risultato di un controllo di visibilità.

• ExecuteClientApiCompatibility assegna lo stato. LosOptions dato un argomento e restituisce lo stesso campo. La chiamata non esegue CheckLOS e non controlla i muri.
• L'impostazione appartiene al runtime. Non garantisce la visibilità del server e non è un modo per superare gli ostacoli.
• In un normale host client, questi dati di stato vengono presi dal gestore GetPersistentState e sono comuni a script/chat/macro dello stesso mondo/profilo e non appartengono a uno script. Un altro processo o un InjectionRuntimeState apparentemente separato ha uno stato diverso. Caricare/cancellare un profilo può sostituirlo; salvati serial vengono ancora confrontati con il mondo caricato.
• 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.LOSOptions();
UO.Print(result is Array values ? "Count: " + values.Length : Convert.ToString(result));

Parametri e flusso di esecuzione:

• Legge o salva la maschera dei parametri locali LOS runtime.

UO.Print(UO.LOSOptions());

Parametri e flusso di esecuzione:

• ExecuteClientApiCompatibility assegna lo stato. LosOptions dato un argomento e restituisce lo stesso campo. La chiamata non esegue CheckLOS e non controlla i muri.

return  RunScenario();
 object? RunScenario()
{
    var before = UO.LOSOptions();
    UO.Print(UO.LOSOptions(0));
    UO.LOSOptions(before);
    return null;
}

Parametri e flusso di esecuzione:

• L'impostazione appartiene al runtime. Non garantisce la visibilità del server e non è un modo per superare gli ostacoli.

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 original = UO.LOSOptions();
        UO.LOSOptions(original);
        UO.Print(Convert.ToString(UO.LOSOptions() == original));
        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: dynamic / Any.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "losoptions": if (arguments.Length > 0) state.LosOptions = Arg(0); return new InjectionValue(state.LosOptions);

Parametri: value (Any)

Risultato: dynamic / Any.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "losoptions": if (arguments.Length > 0) state.LosOptions = Arg(0); return new InjectionValue(state.LosOptions);

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

string UO.PrivateGetTile(object? x, object? y, object? unknown, object? minTile, object? maxTile);

Cerca il primo graphic nell'intervallo specificato nella cella locale.

• x — coordinate mondiali int della mappa corrente.
• y — coordinate mondiali int della mappa corrente.
• unknown — Il parametro legacy int è conservato nella sintassi, ma il bridge non lo utilizza.
• minTile - int confini inclusivi graphic. L'ordine non cambia automaticamente; minTile>maxTile non corrisponde.
• maxTile - int confini inclusivi graphic. L'ordine non cambia automaticamente; minTile>maxTile non corrisponde.

string "0xXXXX" del primo graphic corrispondente; "0x0000" - nessuna corrispondenza o mappa non caricata. Anche il reale graphic=0 ha questa rappresentazione.

• PrivateGetTile attraversa la catena TNext di tutti gli oggetti cella nell'ordine della mappa e confronta graphic>=minTile && graphic<=maxTile. Solo Statico non filtra e non tiene conto di hue/altezza.
• Nessuna richiesta Pathfinder/server. Per una geometria strutturata precisa, utilizzare GetWorldCell/ReadStaticsXY. La guardia di una carta mancante restituisce la precedente sentinella di non corrispondenza.

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.PrivateGetTile(UO.GetX(), UO.GetY(), 0, 0, 65535);
UO.Print("PrivateGetTile: " + Convert.ToString(result));

Parametri e flusso di esecuzione:

• Cerca il primo graphic nell'intervallo specificato nella cella locale.

UO.Print(UO.PrivateGetTile(UO.GetX(), UO.GetY(), 0, 0, 65535));

Parametri e flusso di esecuzione:

• PrivateGetTile attraversa la catena TNext di tutti gli oggetti cella nell'ordine della mappa e confronta graphic>=minTile && graphic<=maxTile. Solo Statico non filtra e non tiene conto di hue/altezza.

return  RunScenario();
 object? RunScenario()
{
    UO.Print(UO.PrivateGetTile(UO.GetX(), UO.GetY(), 0, 0x0E21, 0x0E21));
    return null;
}

Parametri e flusso di esecuzione:

• Nessuna richiesta Pathfinder/server. Per una geometria strutturata precisa, utilizzare GetWorldCell/ReadStaticsXY. La guardia di una carta mancante restituisce la precedente sentinella di non corrispondenza.

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.PrivateGetTile(UO.GetX(), UO.GetY(), 0, 0, 65535);
        if (Truth(tile != "0x0000"))
        {
            UO.Print(tile);
        }

        return null;
    }

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

C# 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 (Integer), y (Integer), unknown (Integer), minTile (Integer), maxTile (Integer)

Risultato: string / String.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.PrivateGetTile.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.PrivateGetTile: bridge.PrivateGetTile(x, y, unknown, minTile, maxTile).

Codice interno di implementazione; non è uno script autonomo.

public string PrivateGetTile(int x, int y, int unknown, int minTile, int maxTile)

            => bridge.PrivateGetTile(x, y, unknown, minTile, maxTile);

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

dynamic UO.ReadStaticsXY(object? x, object? y, object? worldNum);

Legge i record statici flat della carta corrente nella cella.

• x — coordinate mondiali int della cella.
• y — coordinate mondiali int della cella.
• worldNum — numero int della carta corrente. Un'altra mappa non viene caricata e fornisce un array vuoto.

Array int, triple [graphic, Z, hue, graphic, Z, hue, ...]. Nessuna mappa/mancata corrispondenza WorldNum è un array vuoto.

• Bridge.GetStaticTiles include Static, Multi e Item dalla catena TNext della cella; Sono esclusi i terreni. Questo non è un record Pascal o un array di record di tre elementi nidificati.
• Numero di record = ArrayLength(risultato)/3. Vengono letti solo i dati scaricati; non ci sono richieste di geometria sconosciuta al server.

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

Parametri e flusso di esecuzione:

• Legge i record statici flat della carta corrente nella cella.

var records = UO.ReadStaticsXY(UO.GetX(), UO.GetY(), UO.WorldNum());
UO.Print(UO.GetArrayLength(records) / 3);

Parametri e flusso di esecuzione:

• Bridge.GetStaticTiles include Static, Multi e Item dalla catena TNext della cella; Sono esclusi i terreni. Questo non è un record Pascal o un array di record di tre elementi nidificati.

return  RunScenario();
 object? RunScenario()
{
    var records = UO.ReadStaticsXY(UO.GetX(), UO.GetY(), UO.WorldNum());
    if (Truth(UO.GetArrayLength(records) >= 3))
    {
        UO.Print(records[0]);
        UO.Print(records[1]);
        UO.Print(records[2]);
    }

    return null;
}

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:

• Numero di record = ArrayLength(risultato)/3. Vengono letti solo i dati scaricati; non ci sono richieste di geometria sconosciuta al server.

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 map = UO.WorldNum();
        var records = UO.ReadStaticsXY(UO.GetX(), UO.GetY(), map);
        var i = 0;
        while (Truth(i + 2 < UO.GetArrayLength(records)))
        {
            UO.Print(Convert.ToString(records[i]) + " " + Convert.ToString(records[i + 1]) + " " + Convert.ToString(records[i + 2]));
            i = i + 3;
        }

        return null;
    }

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

C# 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), worldNum (Any)

Risultato: dynamic / Any.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "readstaticsxy":

                    return new InjectionValue(bridge.GetStaticTiles(Arg(0), Arg(1), Arg(2)).Select(value => new InjectionValue(value)).ToArray());

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

dynamic UO.RemoveUserStatic(object? id);

Elimina il record statico dell'utente su ID.

• id - int ID, restituito AddUserStatic; non graphic/type.

Flag numerico int: 1 - il record è stato cancellato, 0 - ID mancante.

• Primo stato.UserStatics.Rimuovi; solo se la cancellazione ha esito positivo, viene chiamato bridge.RemoveUserStatic(id). La cancellazione non si applica ai file di mappa statici standard.
• La geometria personalizzata locale viene rimossa dallo stato corrente. Gli elementi del server e gli altri elementi ID non cambiano.
• In un normale host client, questi dati di stato vengono presi dal gestore GetPersistentState e sono comuni a script/chat/macro dello stesso mondo/profilo e non appartengono a uno script. Un altro processo o un InjectionRuntimeState apparentemente separato ha uno stato diverso. Caricare/cancellare un profilo può sostituirlo; salvati serial vengono ancora confrontati con il mondo caricato.

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

Parametri e flusso di esecuzione:

• Elimina il record statico dell'utente su ID.

UO.Print(UO.RemoveUserStatic(1));

Parametri e flusso di esecuzione:

• Primo stato.UserStatics.Rimuovi; solo se la cancellazione ha esito positivo, viene chiamato bridge.RemoveUserStatic(id). La cancellazione non si applica ai file di mappa statici standard.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.UserStaticExists(1)))
    {
        UO.Print(UO.RemoveUserStatic(1));
    }

    return null;
}

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:

• La geometria personalizzata locale viene rimossa dallo stato corrente. Gli elementi del server e gli altri elementi ID non cambiano.

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 records = UO.GetUserStatics();
        if (Truth(UO.GetArrayLength(records) > 0))
        {
            var id = records[0][0];
            UO.Print(UO.RemoveUserStatic(id));
            UO.Print(UO.UserStaticExists(id));
        }

        return null;
    }

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

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)

Risultato: dynamic / Any.

Durante la chiamata:

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

Codice interno di implementazione; non è uno script autonomo.

case "removeuserstatic":

                {

                    int id = Arg(0);

                    bool removed = state.UserStatics.Remove(id);

                    if (removed) bridge.RemoveUserStatic(id);

                    return new InjectionValue(removed ? 1 : 0);

                }

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

int UO.UserStaticExists(object? id);

Verifica la presenza di ID nei record statici dell'utente.

• id — int ID AddUserStatic; non graphic/type e non serial.

Flag numerico int: 1 - la chiave è nello stato. UserStatics, 0 - assente.

• Solo ContainsKey è selezionato nel dizionario di runtime. La visibilità di un oggetto sulla mappa, la creazione riuscita di un oggetto ponte e il mondo del server non vengono controllati.
• Legge lo stato locale attuale. Non esiste alcun pacchetto, destinazione o aggiornamento automatico; le singole letture possono vedere stati diversi.
• In un normale host client, questi dati di stato vengono presi dal gestore GetPersistentState e sono comuni a script/chat/macro dello stesso mondo/profilo e non appartengono a uno script. Un altro processo o un InjectionRuntimeState apparentemente separato ha uno stato diverso. Caricare/cancellare un profilo può sostituirlo; salvati serial vengono ancora confrontati con il mondo caricato.

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

Parametri e flusso di esecuzione:

• Verifica la presenza di ID nei record statici dell'utente.

UO.Print(UO.UserStaticExists(1));

Parametri e flusso di esecuzione:

• Solo ContainsKey è selezionato nel dizionario di runtime. La visibilità di un oggetto sulla mappa, la creazione riuscita di un oggetto ponte e il mondo del server non vengono controllati.

return  RunScenario();
 object? RunScenario()
{
    if (Truth(UO.UserStaticExists(1)))
    {
        UO.Print(UO.GetUserStatic(1));
    }

    return null;
}

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:

• Legge lo stato locale attuale. Non esiste alcun pacchetto, destinazione o aggiornamento automatico; le singole letture possono vedere stati diversi.

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 records = UO.GetUserStatics();
        if (Truth(UO.GetArrayLength(records) > 0))
        {
            UO.Print(UO.UserStaticExists(records[0][0]));
        }

        return null;
    }

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

C# 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)

Risultato: int / Integer.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.UserStaticExists.
• InjectionScript.Runtime.NumberConversions.ToInt: NumberConversions.ToInt(id).

Codice interno di implementazione; non è uno script autonomo.

public int UserStaticExists(InjectionValue id)

            => state.UserStatics.ContainsKey(NumberConversions.ToInt(id)) ? 1 : 0;

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

dynamic UO.WorldNum();

Legge il numero della carta corrente dal modello client.

Non ci sono parametri.

int — indice della carta attuale del cliente, solitamente 0=Felucca, 1=Trammel, 2=Ilshenar, 3=Malas, 4=Tokuno, 5=Ter Mur. Il server dell'utente può utilizzare un diverso set di carte. 0 è una mappa a tutti gli effetti, non è un segno di errore.

• I dati locali già ricevuti vengono letti. La richiesta non apre lo stato e non forza il server a inviare un aggiornamento. Dopo la morte, la transizione della mappa o l'eliminazione di un oggetto, i valori possono cambiare tra due chiamate.
• C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

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

Parametri e flusso di esecuzione:

• La chiamata senza argomenti si riferisce a self. Il numero della carta attuale viene memorizzato in valore.
• Convert.ToString converte il numero da emettere e non cambia il significato del risultato.

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

Parametri e flusso di esecuzione:

• Il valore viene letto una volta senza argomenti. Il numero della carta corrente viene utilizzato nel calcolo o nella condizione mostrata.
• Le soglie numeriche sono esempi di condizioni di script e non di nuovi limiti client. Il campo memorizza le unità server e le restrizioni sopra descritte.

return  RunScenario();
 object? RunScenario()
{
    var value = UO.WorldNum();
    var land = UO.GetLandscapeTile(UO.GetX(), UO.GetY(), value);
    UO.Print("Land record length: " + Convert.ToString(ArrayLength(land)));
    return null;
}

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

Parametri e flusso di esecuzione:

• Entrambe le chiamate senza argomento leggono il loro valore corrente. UO.Wait(1000) dà una pausa in millisecondi tra gli scatti.
• La variazione confrontata è il numero della carta attuale. Un esempio non cambia nulla al mondo e non aspetta all'infinito. Gli eventi entro questo secondo potrebbero essere persi.

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

    async public Task<object?> RunScenarioAsync()
    {
        var before = UO.WorldNum();
        await Delay(1000);
        var after = UO.WorldNum();
        if (Truth(before != after))
        {
            UO.Print("Before: " + Convert.ToString(before) + "; after: " + Convert.ToString(after));
        }

        return null;
    }

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

C# 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: dynamic / Any.

Durante la chiamata:

• InjectionScript.Runtime.InjectionApiUO.ExecuteClientApiCompatibility.
• ClassicUO.Game.Managers.ClassicUOInjectionApiBridge.WorldNumber: bridge.WorldNumber.

Codice interno di implementazione; non è uno script autonomo.

case "worldnum": return new InjectionValue(bridge.WorldNumber);

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

int UO.X();

Legge la coordinata X dal modello client.

Non ci sono parametri.

int è la coordinata X dell'oggetto caricato. Per un personaggio/oggetto del mondo, questa è la cella del mondo; per un oggetto nella borsa, questa è la coordinata all'interno del contenitore. Un oggetto sconosciuto dà 0, ma è valido anche X=0.

• I dati locali già ricevuti vengono letti. La richiesta non apre lo stato e non forza il server a inviare un aggiornamento. Dopo la morte, la transizione della mappa o l'eliminazione di un oggetto, i valori possono cambiare tra due chiamate.
• C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

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

Parametri e flusso di esecuzione:

• La chiamata senza argomenti si riferisce a self. La coordinata x viene memorizzata in value.
• Convert.ToString converte il numero da emettere e non cambia il significato del risultato.

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

Parametri e flusso di esecuzione:

• Il valore viene letto una volta senza argomenti. La coordinata x viene utilizzata nel calcolo o nella condizione mostrata.
• Le soglie numeriche sono esempi di condizioni di script e non di nuovi limiti client. Il campo memorizza le unità server e le restrizioni sopra descritte.

return  RunScenario();
 object? RunScenario()
{
    var value = UO.X();
    UO.Print("Two tiles east would be X=" + Convert.ToString(value + 2));
    return null;
}

Parametri e flusso di esecuzione:

• Entrambe le chiamate senza argomento leggono il loro valore corrente. UO.Wait(1000) dà una pausa in millisecondi tra gli scatti.
• La variazione viene confrontata: la coordinata X. L'esempio non cambia nulla al mondo e non aspetta all'infinito. Gli eventi entro questo secondo potrebbero essere persi.

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

    async public Task<object?> RunScenarioAsync()
    {
        var before = UO.X();
        await Delay(1000);
        var after = UO.X();
        if (Truth(before != after))
        {
            UO.Print("Before: " + Convert.ToString(before) + "; after: " + Convert.ToString(after));
        }

        return null;
    }

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

C# 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: int / Integer.

Durante la chiamata:

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

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.

() => bridge.GetX(bridge.Self)

Creazione API: Queste funzioni registrano l’API. Non vengono eseguite di nuovo a ogni chiamata del comando.

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

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

int UO.Y();

Legge la coordinata Y dal modello client.

Non ci sono parametri.

int — Coordinata Y dell'oggetto caricato. Per un personaggio/oggetto del mondo questa è la cella del mondo, per un oggetto nella borsa questa è la posizione all'interno del contenitore. Un oggetto sconosciuto dà 0.

• I dati locali già ricevuti vengono letti. La richiesta non apre lo stato e non forza il server a inviare un aggiornamento. Dopo la morte, la transizione della mappa o l'eliminazione di un oggetto, i valori possono cambiare tra due chiamate.
• C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

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

Parametri e flusso di esecuzione:

• La chiamata senza argomenti si riferisce a self. La coordinata y viene memorizzata in valore.
• Convert.ToString converte il numero da emettere e non cambia il significato del risultato.

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

Parametri e flusso di esecuzione:

• Il valore viene letto una volta senza argomenti. La coordinata y viene utilizzata nel calcolo o nella condizione mostrata.
• Le soglie numeriche sono esempi di condizioni di script e non di nuovi limiti client. Il campo memorizza le unità server e le restrizioni sopra descritte.

return  RunScenario();
 object? RunScenario()
{
    var value = UO.Y();
    UO.Print("Two tiles south would be Y=" + Convert.ToString(value + 2));
    return null;
}

Parametri e flusso di esecuzione:

• Entrambe le chiamate senza argomento leggono il loro valore corrente. UO.Wait(1000) dà una pausa in millisecondi tra gli scatti.
• La variazione viene confrontata: la coordinata Y. L'esempio non cambia nulla al mondo e non aspetta all'infinito. Gli eventi entro questo secondo potrebbero essere persi.

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

    async public Task<object?> RunScenarioAsync()
    {
        var before = UO.Y();
        await Delay(1000);
        var after = UO.Y();
        if (Truth(before != after))
        {
            UO.Print("Before: " + Convert.ToString(before) + "; after: " + Convert.ToString(after));
        }

        return null;
    }

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

C# 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: int / Integer.

Durante la chiamata:

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

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.

() => bridge.GetY(bridge.Self)

Creazione API: Queste funzioni registrano l’API. Non vengono eseguite di nuovo a ogni chiamata del comando.

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

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

int UO.Z();

Legge l'altezza Z dal modello client.

Non ci sono parametri.

int è l'altezza dell'oggetto in unità mondiali, solitamente -128..127. Questo non è un numero di piano o un livello di attrezzatura. 0 può essere l'altezza effettiva o il risultato dell'assenza di un oggetto.

• I dati locali già ricevuti vengono letti. La richiesta non apre lo stato e non forza il server a inviare un aggiornamento. Dopo la morte, la transizione della mappa o l'eliminazione di un oggetto, i valori possono cambiare tra due chiamate.
• C# distingue maiuscole e minuscole. Usare il nome UO esatto. Confrontare i flag numerici con 0; usare bool solo se la firma restituisce bool.

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